@3driseai/3drise-viewer 0.1.6 → 0.1.8

package/dist/shaders/glsl/landscapeCore.glsl.js

@@ -0,0 +1,518 @@
+/**
+ * Landscape GLSL — heightmap displacement, splat resolve, and the surface
+ * sampling that turns eight tiling materials into ground.
+ *
+ * Injected into a stock `MeshStandardMaterial` through `onBeforeCompile`, so
+ * every one of these snippets has to coexist with three's own chunks. Two
+ * consequences worth knowing before editing:
+ *
+ * - **three r163+ compiles every material as `#version 300 es`** and prepends
+ *   `#define varying in/out`, `#define texture2D texture` and a `gl_FragColor`
+ *   alias. So `sampler2DArray` and `textureGrad` are available with no
+ *   `glslVersion` override — and setting `glslVersion: GLSL3` would REMOVE the
+ *   `gl_FragColor` alias and break the stock chunks. Write GLSL1-flavoured code
+ *   and let the prefix do the conversion.
+ * - Anything declared here shares a namespace with `<common>`. Everything is
+ *   `ls`-prefixed or `u_ls`-prefixed for that reason.
+ *
+ * A backtick inside one of these template literals terminates the string. It has
+ * cost this codebase a debug cycle twice.
+ */
+/** Uniforms and helpers the vertex stage needs. Shared with the depth material,
+ *  which must displace identically or the landscape's shadow will not match it. */
+export const landscapeVertexPars = /* glsl */ `
+uniform sampler2D u_lsHeight;
+uniform vec2 u_lsHeightSize;
+uniform float u_lsSmoothness;
+uniform float u_lsElevation;
+uniform float u_lsElevationBias;
+uniform float u_lsSize;
+
+varying vec3 vLsWorld;
+varying vec3 vLsNormalW;
+varying float vLsHeight01;
+
+// B-spline bicubic through four bilinear taps. What it is for is 8-bit
+// heightmaps: 256 discrete levels over a kilometre of relief is a staircase, and
+// a bilinear tap keeps every step. Widening the footprint by u_lsSmoothness
+// turns the steps into slopes.
+vec4 lsCubic(float v) {
+  vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;
+  vec4 s = n * n * n;
+  float x = s.x;
+  float y = s.y - 4.0 * s.x;
+  float z = s.z - 4.0 * s.y + 6.0 * s.x;
+  float w = 6.0 - x - y - z;
+  return vec4(x, y, z, w) * (1.0 / 6.0);
+}
+
+float lsHeightBicubic(vec2 uv, vec2 texSize) {
+  vec2 invSize = 1.0 / texSize;
+  vec2 coord = uv * texSize - 0.5;
+  vec2 f = fract(coord);
+  coord -= f;
+
+  vec4 xc = lsCubic(f.x);
+  vec4 yc = lsCubic(f.y);
+  vec4 c = coord.xxyy + vec2(-0.5, 1.5).xyxy;
+  vec4 s = vec4(xc.xz + xc.yw, yc.xz + yc.yw);
+  vec4 o = (c + vec4(xc.yw, yc.yw) / s) * invSize.xxyy;
+
+  float s0 = texture2D(u_lsHeight, o.xz).r;
+  float s1 = texture2D(u_lsHeight, o.yz).r;
+  float s2 = texture2D(u_lsHeight, o.xw).r;
+  float s3 = texture2D(u_lsHeight, o.yw).r;
+  float sx = s.x / (s.x + s.y);
+  float sy = s.z / (s.z + s.w);
+  return mix(mix(s3, s2, sx), mix(s1, s0, sx), sy);
+}
+
+// Normalised height at a UV. NOT wrapped in abs() — the reference does that and
+// it folds every below-zero basin upward, which matters the moment there is
+// water in the scene.
+// Single exit, and the result is initialised at its declaration. Every function
+// in this file is written that way deliberately: ANGLE translates GLSL to HLSL on
+// Windows and rewrites an early return into an assignment plus a jump, which
+// D3D's compiler then reports as X4000 "use of potentially uninitialized
+// variable" naming the function's own result. It is a warning rather than an
+// error and the shader links either way, but the pattern is worth avoiding — the
+// analysis that produces the warning is the same one that decides what to
+// initialise.
+float lsHeightAt(vec2 uv) {
+  vec2 c = clamp(uv, 0.0, 1.0);
+  float h = 0.0;
+  if (u_lsSmoothness > 0.001) {
+    h = lsHeightBicubic(c, u_lsHeightSize / max(u_lsSmoothness, 0.001));
+  } else {
+    h = texture2D(u_lsHeight, c).r;
+  }
+  return h;
+}
+
+float lsWorldHeight(vec2 uv) {
+  return lsHeightAt(uv) * u_lsElevation + u_lsElevationBias;
+}
+
+// Surface normal by central difference at the heightmap's real texel size and
+// the real elevation scale. The reference hardcodes both (1.0/1024.0 and 120.0),
+// so its normals are only correct for one map at one scale, and its smoothed
+// variant returns abs(cross(...)) — a normal with the sign stripped, which is
+// why that API needs per-surface normal-flipping flags to paper over it.
+vec3 lsSurfaceNormal(vec2 uv) {
+  vec2 texel = 1.0 / u_lsHeightSize;
+  float hL = lsWorldHeight(uv - vec2(texel.x, 0.0));
+  float hR = lsWorldHeight(uv + vec2(texel.x, 0.0));
+  float hD = lsWorldHeight(uv - vec2(0.0, texel.y));
+  float hU = lsWorldHeight(uv + vec2(0.0, texel.y));
+  // World distance spanned by the two taps on each axis.
+  float dx = 2.0 * texel.x * u_lsSize;
+  float dz = 2.0 * texel.y * u_lsSize;
+  return normalize(vec3(-(hR - hL) * dz, dx * dz, -(hU - hD) * dx));
+}
+`;
+/** Replaces `<begin_vertex>`. Displaces along local +Y and fills the varyings. */
+export const landscapeVertexBody = /* glsl */ `
+vec3 transformed = vec3(position);
+float lsH01 = lsHeightAt(uv);
+transformed.y += lsH01 * u_lsElevation + u_lsElevationBias;
+vLsHeight01 = lsH01;
+vLsWorld = (modelMatrix * vec4(transformed, 1.0)).xyz;
+vLsNormalW = normalize(mat3(modelMatrix) * lsSurfaceNormal(uv));
+`;
+/** Replaces `<beginnormal_vertex>`. The geometry carries a flat up-normal — the
+ *  shape is entirely in the heightmap — so the real normal is evaluated here and
+ *  three's lighting sees a correctly shaded surface with no extra chunk. */
+export const landscapeNormalBody = /* glsl */ `
+vec3 objectNormal = lsSurfaceNormal(uv);
+`;
+/**
+ * Fragment uniforms, samplers and the surface sampling machinery.
+ *
+ * Compile-time counts rather than runtime loops: LS_COUNT is the actual surface
+ * count and LS_SAMPLES the blend width, so every loop here has constant bounds
+ * and unrolls. The reference runs an eight-element insertion sort in a dynamic
+ * while loop on every pixel of the screen.
+ */
+export const landscapeFragmentPars = /* glsl */ `
+uniform sampler2DArray u_lsDiffuse;
+uniform sampler2DArray u_lsNormal;     // rgb tangent-space normal, a surface height
+uniform sampler2D u_lsSplat0;
+uniform sampler2D u_lsSplat1;
+uniform sampler2D u_lsAo;
+// The height field as the fragment stage sees it: RG the one-texel gradient,
+// biased by u_lsGradScale, B the height. One fetch replaces two interpolated
+// varyings that were quantising both the splat and the shading to the
+// triangulation. See buildFieldTexture.
+uniform sampler2D u_lsField;
+uniform float u_lsGradScale;
+uniform vec2 u_lsFieldTexel;
+
+// repeat, normalStrength, roughness, heightBlend
+uniform vec4 u_lsSurfA[LS_COUNT];
+// tint.rgb, saturation
+uniform vec4 u_lsSurfB[LS_COUNT];
+// triplanar, flipNormalY, metalness, aperiodic
+uniform vec4 u_lsSurfC[LS_COUNT];
+// mean colour per diffuse layer, for the variance-preserving stochastic blend
+uniform vec3 u_lsSurfMean[LS_COUNT];
+
+uniform vec4 u_lsAuto;         // bandWidth, slopeStart, slopeEnd, noise
+uniform float u_lsAutoBands[LS_COUNT];
+uniform float u_lsNoiseScale;  // 1 / noiseSize, world units
+uniform float u_lsMacro;
+uniform float u_lsMacroScale;
+uniform float u_lsAoIntensity;
+uniform float u_lsSize;
+uniform float u_lsElevation;
+
+varying vec3 vLsWorld;
+varying vec3 vLsNormalW;
+varying float vLsHeight01;
+
+// Arithmetic hash. Never fract(sin(dot(...))): four hashes an octave with two
+// sines each is most of a frame on its own, and this codebase has paid for that
+// lesson once already in the terrain.
+vec2 lsHash2(vec2 p) {
+  vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.xx + p3.yz) * p3.zy);
+}
+
+float lsHash1(vec2 p) {
+  vec3 p3 = fract(vec3(p.xyx) * 0.1031);
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+float lsValueNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(lsHash1(i), lsHash1(i + vec2(1.0, 0.0)), u.x),
+    mix(lsHash1(i + vec2(0.0, 1.0)), lsHash1(i + vec2(1.0, 1.0)), u.x),
+    u.y
+  );
+}
+
+#ifdef LS_STOCHASTIC
+// Triangle-grid stochastic tiling. Three taps at hashed offsets, weighted by the
+// barycentric coordinate of the point in its cell, so the repeat grid stops
+// existing. The blend is variance-preserving: a straight weighted sum of three
+// samples pulls every pixel toward the texture's mean and visibly washes out
+// contrast, which is what the reference's two-tap smoothstep blend does. Dividing
+// the deviation by sqrt(sum(w^2)) restores it. The mean comes from the CPU, where
+// the pixels were already in hand when the array was packed.
+// Cell size, in texture tiles. The point of stochastic tiling is to randomise
+// PATCHES of texture, so a cell wants to be a tile or two across: smaller and it
+// scrambles within a tile, which shows as noise rather than as break-up, and
+// goes sub-pixel almost immediately.
+//
+// The first version used the bare 3.4641 grid on already-tiled UVs, so a cell was
+// a THIRD of a tile — a fraction of a metre on the ground. It went sub-pixel at
+// any distance, the fade dropped it back to plain sampling, and the repeat grid
+// came straight back at exactly the range it exists to hide.
+#define LS_CELL_TILES 1.5
+
+void lsTriGrid(vec2 uv, out vec3 w, out vec2 v1, out vec2 v2, out vec2 v3) {
+  w = vec3(0.0);
+  v1 = vec2(0.0);
+  v2 = vec2(0.0);
+  v3 = vec2(0.0);
+  vec2 skewed = mat2(1.0, 0.0, -0.57735027, 1.15470054) * (uv * (3.4641016 / LS_CELL_TILES));
+  vec2 base = floor(skewed);
+  vec3 t = vec3(fract(skewed), 0.0);
+  t.z = 1.0 - t.x - t.y;
+  if (t.z > 0.0) {
+    w = vec3(t.z, t.y, t.x);
+    v1 = base;
+    v2 = base + vec2(0.0, 1.0);
+    v3 = base + vec2(1.0, 0.0);
+  } else {
+    w = vec3(-t.z, 1.0 - t.y, 1.0 - t.x);
+    v1 = base + vec2(1.0, 1.0);
+    v2 = base + vec2(1.0, 0.0);
+    v3 = base + vec2(0.0, 1.0);
+  }
+}
+
+vec4 lsSampleStochastic(sampler2DArray tex, vec2 uv, float layer, vec3 mean) {
+  vec2 dx = dFdx(uv);
+  vec2 dy = dFdy(uv);
+  vec4 result = vec4(0.0);
+
+  // Stochastic cells per pixel. THIS FADE IS NOT OPTIONAL. A surface tiled 220
+  // times across a two-kilometre landscape has cells a metre or two wide, which
+  // is roughly a pixel by the time the ground is a few hundred metres away: the
+  // three taps then land in unrelated parts of the texture, the variance
+  // correction amplifies the difference, and the far field turns into a moire of
+  // black speckle. Rendered, that looked exactly like shadow acne and was not —
+  // turning shadows off changed nothing and turning stochastic sampling off
+  // fixed it. Past the fade this is a plain sample, which is what the mip chain
+  // is for. Gradients are explicit throughout, so the branch is safe.
+  float footprint = max(length(dx), length(dy)) * (3.4641016 / LS_CELL_TILES);
+  float fade = smoothstep(0.45, 1.10, footprint);
+
+  if (fade > 0.995) {
+    result = textureGrad(tex, vec3(uv, layer), dx, dy);
+  } else {
+    vec3 w;
+    vec2 v1, v2, v3;
+    lsTriGrid(uv, w, v1, v2, v3);
+    vec4 c1 = textureGrad(tex, vec3(uv + lsHash2(v1), layer), dx, dy);
+    vec4 c2 = textureGrad(tex, vec3(uv + lsHash2(v2), layer), dx, dy);
+    vec4 c3 = textureGrad(tex, vec3(uv + lsHash2(v3), layer), dx, dy);
+    vec4 m = vec4(mean, 0.5);
+    vec4 d = w.x * (c1 - m) + w.y * (c2 - m) + w.z * (c3 - m);
+    // Clamped: the correction multiplies the deviation by up to 1.73, which
+    // takes a dark texel below zero and a bright one past one.
+    result = clamp(m + d * inversesqrt(max(dot(w, w), 1e-4)), 0.0, 1.0);
+    if (fade >= 0.005) {
+      result = mix(result, textureGrad(tex, vec3(uv, layer), dx, dy), fade);
+    }
+  }
+  return result;
+}
+#endif
+
+// Per surface, not per material: stochastic tiling is three fetches instead of
+// one, and only the surfaces a camera gets close to need it. The whole path
+// compiles out when no surface asks for it.
+vec4 lsSampleArray(sampler2DArray tex, vec2 uv, float layer, vec3 mean, float stochastic) {
+  vec4 result = vec4(0.0);
+#ifdef LS_STOCHASTIC
+  if (stochastic > 0.5) {
+    result = lsSampleStochastic(tex, uv, layer, mean);
+  } else {
+    result = texture(tex, vec3(uv, layer));
+  }
+#else
+  result = texture(tex, vec3(uv, layer));
+#endif
+  return result;
+}
+
+#ifdef LS_TRIPLANAR
+// Biplanar: the two strongest axes, not three. The third contributes a fraction
+// of a percent on any surface that is not an exact 45 degree corner, and it costs
+// a third of the fetches. The reference ships biplanar samplers and then calls
+// the triplanar path anyway.
+vec4 lsSampleWorld(sampler2DArray tex, vec3 wp, vec3 n, float scale, float layer, vec3 mean, float stochastic) {
+  vec3 an = abs(n);
+  an = an * an * an;
+  an /= max(an.x + an.y + an.z, 1e-4);
+  float lo = min(an.x, min(an.y, an.z));
+  vec3 w = max(an - lo, 0.0);
+  w /= max(w.x + w.y + w.z, 1e-4);
+  vec4 c = vec4(0.0);
+  if (w.x > 0.002) c += w.x * lsSampleArray(tex, wp.zy * scale, layer, mean, stochastic);
+  if (w.y > 0.002) c += w.y * lsSampleArray(tex, wp.xz * scale, layer, mean, stochastic);
+  if (w.z > 0.002) c += w.z * lsSampleArray(tex, wp.xy * scale, layer, mean, stochastic);
+  return c;
+}
+#endif
+
+// Saturation as a luma lerp. The reference runs a full RGB->HSV->RGB round trip
+// per sampled surface per pixel for this.
+vec3 lsSaturate(vec3 c, float s) {
+  return mix(vec3(dot(c, vec3(0.2126, 0.7152, 0.0722))), c, s);
+}
+`;
+/**
+ * The resolve, called from `<map_fragment>`. Fills `lsAlbedo`, `lsNormalW`,
+ * `lsRoughness` and `lsMetalness`, which the roughness, metalness and normal
+ * chunks then read.
+ *
+ * Order matters: the surface heights come out of the normal array's alpha
+ * channel, so the height blend is computed before a single diffuse texel is
+ * fetched, and the diffuse pass already knows its final weights.
+ */
+export const landscapeFragmentBody = /* glsl */ `
+vec2 lsUv = vUv;
+
+// PER FRAGMENT, not per vertex. The first version read an interpolated height
+// and an interpolated normal out of varyings, and both are linear across a
+// triangle: every splat threshold came out as a straight iso-line kinking at
+// triangle edges — big polygonal patches of flat colour — and the shading normal
+// was faceted to match. One fetch of the field texture fixes both, and makes the
+// mesh resolution invisible to the shading: the ground reads smooth however
+// coarse the triangles under it are.
+vec4 lsField = texture2D(u_lsField, lsUv);
+float lsHeight01 = lsField.b;
+
+// Gradient back to a world-space normal. dx and dz are the world distance one
+// field texel spans, so the normal is correct at any size and elevation rather
+// than only at the one it was authored for.
+vec2 lsGrad = (lsField.rg * 2.0 - 1.0) * u_lsGradScale;
+float lsDx = u_lsFieldTexel.x * u_lsSize;
+float lsDz = u_lsFieldTexel.y * u_lsSize;
+vec3 lsN = normalize(vec3(
+  -lsGrad.x * u_lsElevation * lsDz,
+  lsDx * lsDz,
+  -lsGrad.y * u_lsElevation * lsDx
+));
+
+// Slope as a fraction of vertical rather than 1 - n.y: the naive form is badly
+// compressed at the angles that matter, so every threshold crowds into the top
+// of its range and rock never appears where it should. This way 0.5 IS 45
+// degrees. Same reasoning as the terrain material.
+float lsSlope = acos(clamp(lsN.y, -1.0, 1.0)) * 0.63661977;
+
+// ---- surface weights ------------------------------------------------------
+float lsW[LS_COUNT];
+
+#ifdef LS_AUTO
+// Generated from the heightmap's own height and slope, so a bare heightmap with
+// no authored splat map still renders as ground. Same rule the procedural
+// terrain shades by: everything by height, rock by slope, rock applied last.
+float lsHJit = lsHeight01 + (lsValueNoise(vLsWorld.xz * u_lsNoiseScale) - 0.5) * u_lsAuto.w;
+float lsRock = smoothstep(u_lsAuto.y, u_lsAuto.z, lsSlope);
+for (int i = 0; i < LS_COUNT; i++) {
+  float d = abs(lsHJit - u_lsAutoBands[i]);
+  lsW[i] = max(1.0 - d / max(u_lsAuto.x, 1e-3), 0.0);
+}
+// The last surface is the rock layer.
+for (int i = 0; i < LS_COUNT - 1; i++) lsW[i] *= (1.0 - lsRock);
+lsW[LS_COUNT - 1] = max(lsW[LS_COUNT - 1], lsRock);
+#else
+vec4 lsS0 = texture2D(u_lsSplat0, lsUv);
+lsW[0] = lsS0.r;
+#if LS_COUNT > 1
+lsW[1] = lsS0.g;
+#endif
+#if LS_COUNT > 2
+lsW[2] = lsS0.b;
+#endif
+#if LS_COUNT > 3
+lsW[3] = lsS0.a;
+#endif
+#if LS_COUNT > 4
+vec4 lsS1 = texture2D(u_lsSplat1, lsUv);
+lsW[4] = lsS1.r;
+#endif
+#if LS_COUNT > 5
+lsW[5] = lsS1.g;
+#endif
+#if LS_COUNT > 6
+lsW[6] = lsS1.b;
+#endif
+#if LS_COUNT > 7
+lsW[7] = lsS1.a;
+#endif
+#endif
+
+// ---- pick the heaviest LS_SAMPLES ----------------------------------------
+// Constant bounds both ways, so this unrolls. No sort, no swaps, no dynamic
+// loop: LS_SAMPLES passes each taking the largest remaining weight.
+int lsIdx[LS_SAMPLES];
+float lsWt[LS_SAMPLES];
+for (int s = 0; s < LS_SAMPLES; s++) {
+  int best = 0;
+  float bw = -1.0;
+  for (int i = 0; i < LS_COUNT; i++) {
+    if (lsW[i] > bw) { bw = lsW[i]; best = i; }
+  }
+  lsIdx[s] = best;
+  lsWt[s] = max(bw, 0.0);
+  lsW[best] = -1.0;
+}
+
+// ---- normals and heights, then the height blend ---------------------------
+vec4 lsNrm[LS_SAMPLES];
+float lsBlendRange = 1.0;
+float lsPeak = -1e9;
+float lsV[LS_SAMPLES];
+
+for (int s = 0; s < LS_SAMPLES; s++) {
+  int i = lsIdx[s];
+  float repeat = u_lsSurfA[i].x;
+  vec2 uv = lsUv * repeat;
+  vec3 mean = vec3(0.5, 0.5, 1.0);
+  float stoch = u_lsSurfC[i].w;
+  vec4 n;
+  #ifdef LS_TRIPLANAR
+  if (u_lsSurfC[i].x > 0.5) {
+    n = lsSampleWorld(u_lsNormal, vLsWorld, lsN, repeat / max(u_lsSize, 1e-3), float(i), mean, stoch);
+  } else {
+    n = lsSampleArray(u_lsNormal, uv, float(i), mean, stoch);
+  }
+  #else
+  n = lsSampleArray(u_lsNormal, uv, float(i), mean, stoch);
+  #endif
+  lsNrm[s] = n;
+
+  // Height blending. Two surfaces meeting no longer cross-fade: the one whose
+  // own height map is higher at this texel wins, so gravel comes through grass
+  // along the gravel's grain. The reference loads these height maps and never
+  // samples them.
+  float hb = u_lsSurfA[i].w;
+  lsBlendRange = min(lsBlendRange, mix(1.0, 0.04, hb));
+  lsV[s] = lsWt[s] + n.a * hb;
+  lsPeak = max(lsPeak, lsV[s]);
+}
+
+float lsSum = 0.0;
+for (int s = 0; s < LS_SAMPLES; s++) {
+  lsWt[s] = max(lsV[s] - (lsPeak - lsBlendRange), 0.0);
+  lsSum += lsWt[s];
+}
+lsSum = max(lsSum, 1e-4);
+for (int s = 0; s < LS_SAMPLES; s++) lsWt[s] /= lsSum;
+
+// ---- albedo, normal, roughness -------------------------------------------
+vec3 lsAlbedo = vec3(0.0);
+vec3 lsNsum = vec3(0.0);
+float lsRoughness = 0.0;
+float lsMetalness = 0.0;
+
+for (int s = 0; s < LS_SAMPLES; s++) {
+  int i = lsIdx[s];
+  float w = lsWt[s];
+  float repeat = u_lsSurfA[i].x;
+  vec2 uv = lsUv * repeat;
+
+  float stoch = u_lsSurfC[i].w;
+  vec4 d;
+  #ifdef LS_TRIPLANAR
+  if (u_lsSurfC[i].x > 0.5) {
+    d = lsSampleWorld(u_lsDiffuse, vLsWorld, lsN, repeat / max(u_lsSize, 1e-3), float(i), u_lsSurfMean[i], stoch);
+  } else {
+    d = lsSampleArray(u_lsDiffuse, uv, float(i), u_lsSurfMean[i], stoch);
+  }
+  #else
+  d = lsSampleArray(u_lsDiffuse, uv, float(i), u_lsSurfMean[i], stoch);
+  #endif
+
+  vec3 col = lsSaturate(d.rgb, u_lsSurfB[i].w) * u_lsSurfB[i].rgb;
+  lsAlbedo += col * w;
+
+  // Whiteout-style blend: sum the tangent-space XY, keep Z positive, normalise
+  // once at the end. The reference slerps every surface against a flat normal
+  // and then RNM-blends the result — an acos and three sines per sampled
+  // surface, per pixel.
+  vec3 m = lsNrm[s].rgb * 2.0 - 1.0;
+  m.y *= u_lsSurfC[i].y;
+  m.xy *= u_lsSurfA[i].y;
+  lsNsum += m * w;
+
+  lsRoughness += u_lsSurfA[i].z * w;
+  lsMetalness += u_lsSurfC[i].z * w;
+}
+
+// Large-scale albedo break-up, generated rather than sampled. Without it a splat
+// layer is one flat colour across hundreds of metres and reads as untextured;
+// the reference ships a 2.7 MB texture to do this.
+if (u_lsMacro > 0.001) {
+  float macro = lsValueNoise(vLsWorld.xz * u_lsMacroScale) * 0.6
+              + lsValueNoise(vLsWorld.xz * u_lsMacroScale * 2.7) * 0.4;
+  lsAlbedo *= mix(1.0, 0.6 + macro * 0.8, u_lsMacro);
+}
+
+vec3 lsMapN = normalize(vec3(lsNsum.xy, max(1.0 - length(lsNsum.xy) * 0.5, 0.05)));
+// Tangent frame for a heightfield with axis-aligned UVs: world X, orthogonalised
+// against the surface normal. No tangent attribute and no derivative-based TBN
+// needed, because the mapping is known.
+vec3 lsT = normalize(vec3(1.0, 0.0, 0.0) - lsN * lsN.x);
+vec3 lsB = cross(lsN, lsT);
+vec3 lsNormalW = normalize(lsT * lsMapN.x + lsB * lsMapN.y + lsN * lsMapN.z);
+`;

package/dist/shaders/glsl/noiseBake.glsl.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Bake-time noise. Runs once at startup, never per frame.
+ *
+ * Everything here is *tileable*: the hash wraps its lattice with mod(p, freq) so the
+ * volumes repeat seamlessly under RepeatWrapping. Non-tileable noise in a repeating
+ * 3D texture produces a visible grid of seams across the sky, which is the single most
+ * common giveaway in a volumetric cloud implementation.
+ */
+export declare const bakeCommon = "\n#define PI 3.14159265359\n#define saturate(x) clamp(x, 0.0, 1.0)\nfloat remap(float v, float a, float b, float c, float d){\n  return c + (v - a) * (d - c) / max(b - a, 1e-6);\n}\n\nvec3 hash33t(vec3 p, float f){\n  p = mod(p, vec3(f));\n  p = fract(p * vec3(0.1031, 0.1030, 0.0973));\n  p += dot(p, p.yxz + 19.19);\n  return fract((p.xxy + p.yxx) * p.zyx);\n}\nvec2 hash22t(vec2 p, float f){\n  p = mod(p, vec2(f));\n  vec3 q = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\n  q += dot(q, q.yzx + 19.19);\n  return fract((q.xx + q.yz) * q.zy);\n}\n\nfloat perlin3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  vec3 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n000 = dot(hash33t(i+vec3(0,0,0),f)*2.0-1.0, t-vec3(0,0,0));\n  float n100 = dot(hash33t(i+vec3(1,0,0),f)*2.0-1.0, t-vec3(1,0,0));\n  float n010 = dot(hash33t(i+vec3(0,1,0),f)*2.0-1.0, t-vec3(0,1,0));\n  float n110 = dot(hash33t(i+vec3(1,1,0),f)*2.0-1.0, t-vec3(1,1,0));\n  float n001 = dot(hash33t(i+vec3(0,0,1),f)*2.0-1.0, t-vec3(0,0,1));\n  float n101 = dot(hash33t(i+vec3(1,0,1),f)*2.0-1.0, t-vec3(1,0,1));\n  float n011 = dot(hash33t(i+vec3(0,1,1),f)*2.0-1.0, t-vec3(0,1,1));\n  float n111 = dot(hash33t(i+vec3(1,1,1),f)*2.0-1.0, t-vec3(1,1,1));\n  float x00 = mix(n000,n100,u.x), x10 = mix(n010,n110,u.x);\n  float x01 = mix(n001,n101,u.x), x11 = mix(n011,n111,u.x);\n  return mix(mix(x00,x10,u.y), mix(x01,x11,u.y), u.z);\n}\n\nfloat perlin2(vec2 x, float f){\n  vec2 p = x * f;\n  vec2 i = floor(p); vec2 t = p - i;\n  vec2 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n00 = dot(hash22t(i+vec2(0,0),f)*2.0-1.0, t-vec2(0,0));\n  float n10 = dot(hash22t(i+vec2(1,0),f)*2.0-1.0, t-vec2(1,0));\n  float n01 = dot(hash22t(i+vec2(0,1),f)*2.0-1.0, t-vec2(0,1));\n  float n11 = dot(hash22t(i+vec2(1,1),f)*2.0-1.0, t-vec2(1,1));\n  return mix(mix(n00,n10,u.x), mix(n01,n11,u.x), u.y);\n}\n\nfloat worley3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  float md = 1e9;\n  for(int z=-1; z<=1; z++)\n  for(int y=-1; y<=1; y++)\n  for(int w=-1; w<=1; w++){\n    vec3 o = vec3(float(w), float(y), float(z));\n    vec3 h = hash33t(i + o, f);\n    vec3 d = o + h - t;\n    md = min(md, dot(d, d));\n  }\n  return saturate(sqrt(md));\n}\n";
+export declare const bakeVertex = "\nout vec2 vUv;\nvoid main(){ vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }\n";
+/**
+ * Base shape, 128³ RGBA.
+ *   R = Perlin-Worley (Schneider): perlin fbm remapped by an inverted-worley fbm, which
+ *       gives billowy tops without losing perlin's connectedness.
+ *   G/B/A = inverted worley at 4 / 8 / 16, recombined in the march as the low-frequency
+ *       fbm that erodes R.
+ */
+export declare const bakeBaseFrag = "\n\n#define PI 3.14159265359\n#define saturate(x) clamp(x, 0.0, 1.0)\nfloat remap(float v, float a, float b, float c, float d){\n  return c + (v - a) * (d - c) / max(b - a, 1e-6);\n}\n\nvec3 hash33t(vec3 p, float f){\n  p = mod(p, vec3(f));\n  p = fract(p * vec3(0.1031, 0.1030, 0.0973));\n  p += dot(p, p.yxz + 19.19);\n  return fract((p.xxy + p.yxx) * p.zyx);\n}\nvec2 hash22t(vec2 p, float f){\n  p = mod(p, vec2(f));\n  vec3 q = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\n  q += dot(q, q.yzx + 19.19);\n  return fract((q.xx + q.yz) * q.zy);\n}\n\nfloat perlin3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  vec3 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n000 = dot(hash33t(i+vec3(0,0,0),f)*2.0-1.0, t-vec3(0,0,0));\n  float n100 = dot(hash33t(i+vec3(1,0,0),f)*2.0-1.0, t-vec3(1,0,0));\n  float n010 = dot(hash33t(i+vec3(0,1,0),f)*2.0-1.0, t-vec3(0,1,0));\n  float n110 = dot(hash33t(i+vec3(1,1,0),f)*2.0-1.0, t-vec3(1,1,0));\n  float n001 = dot(hash33t(i+vec3(0,0,1),f)*2.0-1.0, t-vec3(0,0,1));\n  float n101 = dot(hash33t(i+vec3(1,0,1),f)*2.0-1.0, t-vec3(1,0,1));\n  float n011 = dot(hash33t(i+vec3(0,1,1),f)*2.0-1.0, t-vec3(0,1,1));\n  float n111 = dot(hash33t(i+vec3(1,1,1),f)*2.0-1.0, t-vec3(1,1,1));\n  float x00 = mix(n000,n100,u.x), x10 = mix(n010,n110,u.x);\n  float x01 = mix(n001,n101,u.x), x11 = mix(n011,n111,u.x);\n  return mix(mix(x00,x10,u.y), mix(x01,x11,u.y), u.z);\n}\n\nfloat perlin2(vec2 x, float f){\n  vec2 p = x * f;\n  vec2 i = floor(p); vec2 t = p - i;\n  vec2 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n00 = dot(hash22t(i+vec2(0,0),f)*2.0-1.0, t-vec2(0,0));\n  float n10 = dot(hash22t(i+vec2(1,0),f)*2.0-1.0, t-vec2(1,0));\n  float n01 = dot(hash22t(i+vec2(0,1),f)*2.0-1.0, t-vec2(0,1));\n  float n11 = dot(hash22t(i+vec2(1,1),f)*2.0-1.0, t-vec2(1,1));\n  return mix(mix(n00,n10,u.x), mix(n01,n11,u.x), u.y);\n}\n\nfloat worley3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  float md = 1e9;\n  for(int z=-1; z<=1; z++)\n  for(int y=-1; y<=1; y++)\n  for(int w=-1; w<=1; w++){\n    vec3 o = vec3(float(w), float(y), float(z));\n    vec3 h = hash33t(i + o, f);\n    vec3 d = o + h - t;\n    md = min(md, dot(d, d));\n  }\n  return saturate(sqrt(md));\n}\n\n\nin vec2 vUv;\nout vec4 outColor;\n\n\nuniform vec2 u_atlas;\nuniform float u_tiles;\nuniform float u_res;\nvec3 volCoord(){\n  vec2 px   = floor(vUv * u_atlas);\n  vec2 tile = floor(px / u_res);\n  float z   = tile.y * u_tiles + tile.x;\n  vec2 xy   = px - tile * u_res;\n  return (vec3(xy, z) + 0.5) / u_res;\n}\n\nvoid main(){\n  vec3 p = volCoord();\n  float pf = perlin3(p, 4.0) * 0.5 + perlin3(p, 8.0) * 0.25\n           + perlin3(p, 16.0) * 0.125 + perlin3(p, 32.0) * 0.0625;\n  pf = saturate(pf * 1.35 + 0.5);\n  float w4  = 1.0 - worley3(p,  4.0);\n  float w8  = 1.0 - worley3(p,  8.0);\n  float w16 = 1.0 - worley3(p, 16.0);\n  float wfbm = saturate(w4 * 0.625 + w8 * 0.25 + w16 * 0.125);\n  outColor = vec4(saturate(remap(pf, wfbm - 1.0, 1.0, 0.0, 1.0)), w4, w8, w16);\n}\n";
+/** Detail erosion, 64³ RGB inverted worley at 4 / 8 / 16. */
+export declare const bakeDetailFrag = "\n\n#define PI 3.14159265359\n#define saturate(x) clamp(x, 0.0, 1.0)\nfloat remap(float v, float a, float b, float c, float d){\n  return c + (v - a) * (d - c) / max(b - a, 1e-6);\n}\n\nvec3 hash33t(vec3 p, float f){\n  p = mod(p, vec3(f));\n  p = fract(p * vec3(0.1031, 0.1030, 0.0973));\n  p += dot(p, p.yxz + 19.19);\n  return fract((p.xxy + p.yxx) * p.zyx);\n}\nvec2 hash22t(vec2 p, float f){\n  p = mod(p, vec2(f));\n  vec3 q = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\n  q += dot(q, q.yzx + 19.19);\n  return fract((q.xx + q.yz) * q.zy);\n}\n\nfloat perlin3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  vec3 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n000 = dot(hash33t(i+vec3(0,0,0),f)*2.0-1.0, t-vec3(0,0,0));\n  float n100 = dot(hash33t(i+vec3(1,0,0),f)*2.0-1.0, t-vec3(1,0,0));\n  float n010 = dot(hash33t(i+vec3(0,1,0),f)*2.0-1.0, t-vec3(0,1,0));\n  float n110 = dot(hash33t(i+vec3(1,1,0),f)*2.0-1.0, t-vec3(1,1,0));\n  float n001 = dot(hash33t(i+vec3(0,0,1),f)*2.0-1.0, t-vec3(0,0,1));\n  float n101 = dot(hash33t(i+vec3(1,0,1),f)*2.0-1.0, t-vec3(1,0,1));\n  float n011 = dot(hash33t(i+vec3(0,1,1),f)*2.0-1.0, t-vec3(0,1,1));\n  float n111 = dot(hash33t(i+vec3(1,1,1),f)*2.0-1.0, t-vec3(1,1,1));\n  float x00 = mix(n000,n100,u.x), x10 = mix(n010,n110,u.x);\n  float x01 = mix(n001,n101,u.x), x11 = mix(n011,n111,u.x);\n  return mix(mix(x00,x10,u.y), mix(x01,x11,u.y), u.z);\n}\n\nfloat perlin2(vec2 x, float f){\n  vec2 p = x * f;\n  vec2 i = floor(p); vec2 t = p - i;\n  vec2 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n00 = dot(hash22t(i+vec2(0,0),f)*2.0-1.0, t-vec2(0,0));\n  float n10 = dot(hash22t(i+vec2(1,0),f)*2.0-1.0, t-vec2(1,0));\n  float n01 = dot(hash22t(i+vec2(0,1),f)*2.0-1.0, t-vec2(0,1));\n  float n11 = dot(hash22t(i+vec2(1,1),f)*2.0-1.0, t-vec2(1,1));\n  return mix(mix(n00,n10,u.x), mix(n01,n11,u.x), u.y);\n}\n\nfloat worley3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  float md = 1e9;\n  for(int z=-1; z<=1; z++)\n  for(int y=-1; y<=1; y++)\n  for(int w=-1; w<=1; w++){\n    vec3 o = vec3(float(w), float(y), float(z));\n    vec3 h = hash33t(i + o, f);\n    vec3 d = o + h - t;\n    md = min(md, dot(d, d));\n  }\n  return saturate(sqrt(md));\n}\n\n\nin vec2 vUv;\nout vec4 outColor;\n\n\nuniform vec2 u_atlas;\nuniform float u_tiles;\nuniform float u_res;\nvec3 volCoord(){\n  vec2 px   = floor(vUv * u_atlas);\n  vec2 tile = floor(px / u_res);\n  float z   = tile.y * u_tiles + tile.x;\n  vec2 xy   = px - tile * u_res;\n  return (vec3(xy, z) + 0.5) / u_res;\n}\n\nvoid main(){\n  vec3 p = volCoord();\n  outColor = vec4(1.0 - worley3(p, 4.0), 1.0 - worley3(p, 8.0), 1.0 - worley3(p, 16.0), 1.0);\n}\n";
+/**
+ * Weather map, 512² RGBA. Domain-warped so cell edges are not perlin-round.
+ * The warp offsets are themselves tileable, so the map still wraps exactly.
+ *   R = coverage, low frequency        B = cloud type bias
+ *   G = coverage, high frequency       A = precipitation
+ */
+export declare const bakeWeatherFrag = "\n\n#define PI 3.14159265359\n#define saturate(x) clamp(x, 0.0, 1.0)\nfloat remap(float v, float a, float b, float c, float d){\n  return c + (v - a) * (d - c) / max(b - a, 1e-6);\n}\n\nvec3 hash33t(vec3 p, float f){\n  p = mod(p, vec3(f));\n  p = fract(p * vec3(0.1031, 0.1030, 0.0973));\n  p += dot(p, p.yxz + 19.19);\n  return fract((p.xxy + p.yxx) * p.zyx);\n}\nvec2 hash22t(vec2 p, float f){\n  p = mod(p, vec2(f));\n  vec3 q = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\n  q += dot(q, q.yzx + 19.19);\n  return fract((q.xx + q.yz) * q.zy);\n}\n\nfloat perlin3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  vec3 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n000 = dot(hash33t(i+vec3(0,0,0),f)*2.0-1.0, t-vec3(0,0,0));\n  float n100 = dot(hash33t(i+vec3(1,0,0),f)*2.0-1.0, t-vec3(1,0,0));\n  float n010 = dot(hash33t(i+vec3(0,1,0),f)*2.0-1.0, t-vec3(0,1,0));\n  float n110 = dot(hash33t(i+vec3(1,1,0),f)*2.0-1.0, t-vec3(1,1,0));\n  float n001 = dot(hash33t(i+vec3(0,0,1),f)*2.0-1.0, t-vec3(0,0,1));\n  float n101 = dot(hash33t(i+vec3(1,0,1),f)*2.0-1.0, t-vec3(1,0,1));\n  float n011 = dot(hash33t(i+vec3(0,1,1),f)*2.0-1.0, t-vec3(0,1,1));\n  float n111 = dot(hash33t(i+vec3(1,1,1),f)*2.0-1.0, t-vec3(1,1,1));\n  float x00 = mix(n000,n100,u.x), x10 = mix(n010,n110,u.x);\n  float x01 = mix(n001,n101,u.x), x11 = mix(n011,n111,u.x);\n  return mix(mix(x00,x10,u.y), mix(x01,x11,u.y), u.z);\n}\n\nfloat perlin2(vec2 x, float f){\n  vec2 p = x * f;\n  vec2 i = floor(p); vec2 t = p - i;\n  vec2 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n00 = dot(hash22t(i+vec2(0,0),f)*2.0-1.0, t-vec2(0,0));\n  float n10 = dot(hash22t(i+vec2(1,0),f)*2.0-1.0, t-vec2(1,0));\n  float n01 = dot(hash22t(i+vec2(0,1),f)*2.0-1.0, t-vec2(0,1));\n  float n11 = dot(hash22t(i+vec2(1,1),f)*2.0-1.0, t-vec2(1,1));\n  return mix(mix(n00,n10,u.x), mix(n01,n11,u.x), u.y);\n}\n\nfloat worley3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  float md = 1e9;\n  for(int z=-1; z<=1; z++)\n  for(int y=-1; y<=1; y++)\n  for(int w=-1; w<=1; w++){\n    vec3 o = vec3(float(w), float(y), float(z));\n    vec3 h = hash33t(i + o, f);\n    vec3 d = o + h - t;\n    md = min(md, dot(d, d));\n  }\n  return saturate(sqrt(md));\n}\n\n\nin vec2 vUv;\nout vec4 outColor;\n\nvoid main(){\n  vec2 q = vUv;\n  vec2 w = vec2(perlin2(q, 3.0), perlin2(q + vec2(0.37, 0.11), 3.0));\n  vec2 qw = q + w * 0.11;\n  float c1 = perlin2(qw, 3.0) * 0.60 + perlin2(qw, 6.0)  * 0.28 + perlin2(qw, 12.0) * 0.12;\n  float c2 = perlin2(qw, 7.0) * 0.52 + perlin2(qw, 14.0) * 0.30 + perlin2(qw, 28.0) * 0.18;\n  float ty = perlin2(q + vec2(5.1, 2.3), 2.0);\n  float pr = perlin2(q + vec2(1.7, 8.2), 5.0) * 0.7 + perlin2(q + vec2(1.7, 8.2), 10.0) * 0.3;\n  outColor = vec4(\n    saturate(c1 * 1.55 + 0.5),\n    saturate(c2 * 1.60 + 0.5),\n    saturate(ty * 1.60 + 0.5),\n    saturate(pr * 1.60 + 0.5)\n  );\n}\n";
+/** Curl field, 128² RG. Curl of a scalar fbm — divergence free, so it swirls rather than pushes. */
+export declare const bakeCurlFrag = "\n\n#define PI 3.14159265359\n#define saturate(x) clamp(x, 0.0, 1.0)\nfloat remap(float v, float a, float b, float c, float d){\n  return c + (v - a) * (d - c) / max(b - a, 1e-6);\n}\n\nvec3 hash33t(vec3 p, float f){\n  p = mod(p, vec3(f));\n  p = fract(p * vec3(0.1031, 0.1030, 0.0973));\n  p += dot(p, p.yxz + 19.19);\n  return fract((p.xxy + p.yxx) * p.zyx);\n}\nvec2 hash22t(vec2 p, float f){\n  p = mod(p, vec2(f));\n  vec3 q = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\n  q += dot(q, q.yzx + 19.19);\n  return fract((q.xx + q.yz) * q.zy);\n}\n\nfloat perlin3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  vec3 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n000 = dot(hash33t(i+vec3(0,0,0),f)*2.0-1.0, t-vec3(0,0,0));\n  float n100 = dot(hash33t(i+vec3(1,0,0),f)*2.0-1.0, t-vec3(1,0,0));\n  float n010 = dot(hash33t(i+vec3(0,1,0),f)*2.0-1.0, t-vec3(0,1,0));\n  float n110 = dot(hash33t(i+vec3(1,1,0),f)*2.0-1.0, t-vec3(1,1,0));\n  float n001 = dot(hash33t(i+vec3(0,0,1),f)*2.0-1.0, t-vec3(0,0,1));\n  float n101 = dot(hash33t(i+vec3(1,0,1),f)*2.0-1.0, t-vec3(1,0,1));\n  float n011 = dot(hash33t(i+vec3(0,1,1),f)*2.0-1.0, t-vec3(0,1,1));\n  float n111 = dot(hash33t(i+vec3(1,1,1),f)*2.0-1.0, t-vec3(1,1,1));\n  float x00 = mix(n000,n100,u.x), x10 = mix(n010,n110,u.x);\n  float x01 = mix(n001,n101,u.x), x11 = mix(n011,n111,u.x);\n  return mix(mix(x00,x10,u.y), mix(x01,x11,u.y), u.z);\n}\n\nfloat perlin2(vec2 x, float f){\n  vec2 p = x * f;\n  vec2 i = floor(p); vec2 t = p - i;\n  vec2 u = t*t*t*(t*(t*6.0-15.0)+10.0);\n  float n00 = dot(hash22t(i+vec2(0,0),f)*2.0-1.0, t-vec2(0,0));\n  float n10 = dot(hash22t(i+vec2(1,0),f)*2.0-1.0, t-vec2(1,0));\n  float n01 = dot(hash22t(i+vec2(0,1),f)*2.0-1.0, t-vec2(0,1));\n  float n11 = dot(hash22t(i+vec2(1,1),f)*2.0-1.0, t-vec2(1,1));\n  return mix(mix(n00,n10,u.x), mix(n01,n11,u.x), u.y);\n}\n\nfloat worley3(vec3 x, float f){\n  vec3 p = x * f;\n  vec3 i = floor(p); vec3 t = p - i;\n  float md = 1e9;\n  for(int z=-1; z<=1; z++)\n  for(int y=-1; y<=1; y++)\n  for(int w=-1; w<=1; w++){\n    vec3 o = vec3(float(w), float(y), float(z));\n    vec3 h = hash33t(i + o, f);\n    vec3 d = o + h - t;\n    md = min(md, dot(d, d));\n  }\n  return saturate(sqrt(md));\n}\n\n\nin vec2 vUv;\nout vec4 outColor;\n\nfloat fld(vec2 q){ return perlin2(q, 6.0) * 0.6 + perlin2(q, 12.0) * 0.3 + perlin2(q, 24.0) * 0.15; }\nvoid main(){\n  float e = 1.0 / 128.0;\n  float dx = fld(vUv + vec2(e, 0.0)) - fld(vUv - vec2(e, 0.0));\n  float dy = fld(vUv + vec2(0.0, e)) - fld(vUv - vec2(0.0, e));\n  vec2 c = clamp(vec2(dy, -dx) / (2.0 * e) / 26.0, -1.0, 1.0);\n  outColor = vec4(c * 0.5 + 0.5, 0.0, 1.0);\n}\n";
+//# sourceMappingURL=noiseBake.glsl.d.ts.map

package/dist/shaders/glsl/noiseBake.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noiseBake.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/noiseBake.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,UAAU,mtEA8DtB,CAAA;AAED,eAAO,MAAM,UAAU,2FAGtB,CAAA;AAsBD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,w+FAexB,CAAA;AAED,6DAA6D;AAC7D,eAAO,MAAM,cAAc,6pFAQ1B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,o2FAkB3B,CAAA;AAED,oGAAoG;AACpG,eAAO,MAAM,YAAY,8nFAWxB,CAAA"}