@driftengine/core 3.61.0

package/dist/render/shaders/flat/probeGrid.d.ts

@@ -0,0 +1,21 @@
+/** Reading the probe array: which layers a point sits between, and what each of them holds. */
+/**
+ * The lit pass's half of the grid, and the two things it has to get right.
+ *
+ * **A layer index is arithmetic rather than a lookup.** Probes stand on a lattice, so the cell a
+ * point is in comes out of one multiply and a floor, and the eight corner weights are three lerps.
+ * `probeGrid.ts` computes the same thing in TypeScript for a caller pacing its bakes, and the two
+ * expressions have to agree or every fragment reads a probe that was baked somewhere else.
+ *
+ * **Levels are mixed by hand, and the gutter is why.** A level's gutter is one texel, so its inset
+ * in normalised coordinates is `1 / edge` and differs between levels. Hardware trilinear applies
+ * one coordinate to both levels it blends, so one of the two would be read at the wrong inset — by
+ * a thirty-second of the map at the top of the chain, which is a visible slide in a reflection as
+ * roughness rises. Two fetches at their own insets, mixed, is the price of the fold.
+ *
+ * **What it costs**, at the counts below: eight fetches for the diffuse term and four for the
+ * reflection. The diffuse eight are of an eight-texel image and land in the same cache line; the
+ * reflection's four are two probes at two levels. A grid of one collapses to one and two, because
+ * every corner resolves to the same layer and the zero-weight ones are skipped.
+ */
+export declare const PROBEGRID_GLSL = "#if ENVIRONMENT_PROBE\n/**\n * Where a direction lands in one layer at one level, inset past that level's gutter.\n *\n * The level's own edge rather than the map's, since a gutter is one texel at every level and its\n * share of the map doubles as the chain coarsens.\n */\nvec3 probeCoord(vec3 dir, float level, float layer) {\n  float levelEdge = max(uEnvironmentEdge / exp2(level), 4.0);\n  return vec3(octInsetUv(dir, levelEdge), layer);\n}\n\n/**\n * A layer index from whole lattice coordinates: x fastest, then y, then z.\n *\n * Clamped, which is what makes an axis one probe wide safe: the second corner of a pair that does\n * not exist resolves to the first, at a weight the caller has already set to zero.\n */\nfloat probeLayer(vec3 index) {\n  vec3 top = max(uProbeGridCounts - 1.0, vec3(0.0));\n  vec3 held = clamp(index, vec3(0.0), top);\n  return held.x + uProbeGridCounts.x * (held.y + uProbeGridCounts.y * held.z);\n}\n\n/**\n * The cell a world position is in, as a base corner and the fraction past it.\n *\n * **Clamped rather than wrapped**, so a point outside the grid takes the nearest probes at full\n * weight \u2014 the environment it would have had one step inside. Wrapping would light one end of a\n * world with the probe from the other end, which is invisible in any test that stays indoors.\n *\n * An axis one probe wide has its fraction forced to zero, so that axis contributes a factor of one\n * to every corner weight and the eight corners collapse onto fewer layers whose weights still sum\n * to one.\n */\nvoid probeCell(vec3 worldPos, out vec3 base, out vec3 frac) {\n  vec3 top = max(uProbeGridCounts - 1.0, vec3(0.0));\n  vec3 local = clamp((worldPos - uProbeGridOrigin) * uProbeGridInvSpacing, vec3(0.0), top);\n  base = min(floor(local), max(top - 1.0, vec3(0.0)));\n  frac = local - base;\n  frac *= step(vec3(1.5), uProbeGridCounts);\n}\n\n/** One probe's diffuse light: the cosine convolution, at its own level, in one fetch. */\nvec3 probeIrradiance(vec3 dir, float layer) {\n  float level = uEnvironmentIrradianceLevel;\n  return textureLod(uEnvironment, probeCoord(dir, level, layer), level).rgb;\n}\n\n/**\n * One probe's reflection at a roughness, as two levels mixed by hand.\n *\n * textureLod rather than texture throughout, per the 2026-08-07 rule and for a second reason on\n * top of it: the level is wanted here, and the fetches sit inside a loop that no compiler can\n * prove uniform.\n */\nvec3 probeRadiance(vec3 dir, float lod, float layer) {\n  float lo = clamp(floor(lod), 0.0, uEnvironmentMaxLod);\n  float hi = min(lo + 1.0, uEnvironmentMaxLod);\n  vec3 coarse = textureLod(uEnvironment, probeCoord(dir, hi, layer), hi).rgb;\n  vec3 fine = textureLod(uEnvironment, probeCoord(dir, lo, layer), lo).rgb;\n  return mix(fine, coarse, clamp(lod - lo, 0.0, 1.0));\n}\n\n/**\n * The grid's diffuse light at a point, trilinear over the eight probes around it.\n *\n * **Eight, because diffuse is the term a grid exists for.** A floor spanning four probes is the\n * case the whole row was costed against, and a hard selection steps visibly across it \u2014 which is\n * exactly where a lit surface has nothing else going on to hide the seam.\n *\n * Zero-weight corners are skipped, so a grid of one does one fetch rather than eight.\n *\n * The cell is recomputed here rather than passed in, because the two terms sit in separate\n * conditional blocks of the lit pass and threading a pair of vectors between them would mean a\n * third. Six arithmetic operations against that.\n */\nvec3 gridIrradiance(vec3 dir, vec3 worldPos) {\n  vec3 base;\n  vec3 frac;\n  probeCell(worldPos, base, frac);\n  vec3 sum = vec3(0.0);\n  for (int c = 0; c < 8; c++) {\n    vec3 corner = vec3(float(c & 1), float((c >> 1) & 1), float((c >> 2) & 1));\n    vec3 axisWeight = mix(1.0 - frac, frac, corner);\n    float weight = axisWeight.x * axisWeight.y * axisWeight.z;\n    if (weight <= 0.0) continue;\n    sum += probeIrradiance(dir, probeLayer(base + corner)) * weight;\n  }\n  return sum;\n}\n\n/**\n * The grid's reflection at a point: two probes along the axis the point is most between.\n *\n * **Two rather than eight, and the axis is chosen rather than fixed.** Sixteen fetches for a\n * reflection is not affordable on the parts this engine targets, and a single probe pops as a\n * smooth surface crosses a cell boundary. Blending along the axis with the largest betweenness\n * removes the pop where it is largest for one extra pair of fetches; the other two axes take their\n * nearest probe, where the switch happens at the point the blend would have been half and half.\n *\n * Full trilinear here is recorded as deferred rather than refused, with its reversal condition: a\n * consumer measuring the remaining seam as their constraint.\n */\nvec3 gridRadiance(vec3 dir, float lod, vec3 worldPos) {\n  vec3 base;\n  vec3 frac;\n  probeCell(worldPos, base, frac);\n  vec3 between = min(frac, 1.0 - frac);\n  vec3 nearest = base + step(vec3(0.5), frac);\n  vec3 low = nearest;\n  vec3 high = nearest;\n  float t = 0.0;\n  if (between.x >= between.y && between.x >= between.z) {\n    low.x = base.x;\n    high.x = base.x + 1.0;\n    t = frac.x;\n  } else if (between.y >= between.z) {\n    low.y = base.y;\n    high.y = base.y + 1.0;\n    t = frac.y;\n  } else {\n    low.z = base.z;\n    high.z = base.z + 1.0;\n    t = frac.z;\n  }\n  vec3 near = probeRadiance(dir, lod, probeLayer(low));\n  if (t <= 0.0) return near;\n  return mix(near, probeRadiance(dir, lod, probeLayer(high)), t);\n}\n#endif";

package/dist/render/shaders/flat/probeGrid.js

@@ -0,0 +1,151 @@
+/** Reading the probe array: which layers a point sits between, and what each of them holds. */
+/**
+ * The lit pass's half of the grid, and the two things it has to get right.
+ *
+ * **A layer index is arithmetic rather than a lookup.** Probes stand on a lattice, so the cell a
+ * point is in comes out of one multiply and a floor, and the eight corner weights are three lerps.
+ * `probeGrid.ts` computes the same thing in TypeScript for a caller pacing its bakes, and the two
+ * expressions have to agree or every fragment reads a probe that was baked somewhere else.
+ *
+ * **Levels are mixed by hand, and the gutter is why.** A level's gutter is one texel, so its inset
+ * in normalised coordinates is `1 / edge` and differs between levels. Hardware trilinear applies
+ * one coordinate to both levels it blends, so one of the two would be read at the wrong inset — by
+ * a thirty-second of the map at the top of the chain, which is a visible slide in a reflection as
+ * roughness rises. Two fetches at their own insets, mixed, is the price of the fold.
+ *
+ * **What it costs**, at the counts below: eight fetches for the diffuse term and four for the
+ * reflection. The diffuse eight are of an eight-texel image and land in the same cache line; the
+ * reflection's four are two probes at two levels. A grid of one collapses to one and two, because
+ * every corner resolves to the same layer and the zero-weight ones are skipped.
+ */
+export const PROBEGRID_GLSL = `#if ENVIRONMENT_PROBE
+/**
+ * Where a direction lands in one layer at one level, inset past that level's gutter.
+ *
+ * The level's own edge rather than the map's, since a gutter is one texel at every level and its
+ * share of the map doubles as the chain coarsens.
+ */
+vec3 probeCoord(vec3 dir, float level, float layer) {
+  float levelEdge = max(uEnvironmentEdge / exp2(level), 4.0);
+  return vec3(octInsetUv(dir, levelEdge), layer);
+}
+
+/**
+ * A layer index from whole lattice coordinates: x fastest, then y, then z.
+ *
+ * Clamped, which is what makes an axis one probe wide safe: the second corner of a pair that does
+ * not exist resolves to the first, at a weight the caller has already set to zero.
+ */
+float probeLayer(vec3 index) {
+  vec3 top = max(uProbeGridCounts - 1.0, vec3(0.0));
+  vec3 held = clamp(index, vec3(0.0), top);
+  return held.x + uProbeGridCounts.x * (held.y + uProbeGridCounts.y * held.z);
+}
+
+/**
+ * The cell a world position is in, as a base corner and the fraction past it.
+ *
+ * **Clamped rather than wrapped**, so a point outside the grid takes the nearest probes at full
+ * weight — the environment it would have had one step inside. Wrapping would light one end of a
+ * world with the probe from the other end, which is invisible in any test that stays indoors.
+ *
+ * An axis one probe wide has its fraction forced to zero, so that axis contributes a factor of one
+ * to every corner weight and the eight corners collapse onto fewer layers whose weights still sum
+ * to one.
+ */
+void probeCell(vec3 worldPos, out vec3 base, out vec3 frac) {
+  vec3 top = max(uProbeGridCounts - 1.0, vec3(0.0));
+  vec3 local = clamp((worldPos - uProbeGridOrigin) * uProbeGridInvSpacing, vec3(0.0), top);
+  base = min(floor(local), max(top - 1.0, vec3(0.0)));
+  frac = local - base;
+  frac *= step(vec3(1.5), uProbeGridCounts);
+}
+
+/** One probe's diffuse light: the cosine convolution, at its own level, in one fetch. */
+vec3 probeIrradiance(vec3 dir, float layer) {
+  float level = uEnvironmentIrradianceLevel;
+  return textureLod(uEnvironment, probeCoord(dir, level, layer), level).rgb;
+}
+
+/**
+ * One probe's reflection at a roughness, as two levels mixed by hand.
+ *
+ * textureLod rather than texture throughout, per the 2026-08-07 rule and for a second reason on
+ * top of it: the level is wanted here, and the fetches sit inside a loop that no compiler can
+ * prove uniform.
+ */
+vec3 probeRadiance(vec3 dir, float lod, float layer) {
+  float lo = clamp(floor(lod), 0.0, uEnvironmentMaxLod);
+  float hi = min(lo + 1.0, uEnvironmentMaxLod);
+  vec3 coarse = textureLod(uEnvironment, probeCoord(dir, hi, layer), hi).rgb;
+  vec3 fine = textureLod(uEnvironment, probeCoord(dir, lo, layer), lo).rgb;
+  return mix(fine, coarse, clamp(lod - lo, 0.0, 1.0));
+}
+
+/**
+ * The grid's diffuse light at a point, trilinear over the eight probes around it.
+ *
+ * **Eight, because diffuse is the term a grid exists for.** A floor spanning four probes is the
+ * case the whole row was costed against, and a hard selection steps visibly across it — which is
+ * exactly where a lit surface has nothing else going on to hide the seam.
+ *
+ * Zero-weight corners are skipped, so a grid of one does one fetch rather than eight.
+ *
+ * The cell is recomputed here rather than passed in, because the two terms sit in separate
+ * conditional blocks of the lit pass and threading a pair of vectors between them would mean a
+ * third. Six arithmetic operations against that.
+ */
+vec3 gridIrradiance(vec3 dir, vec3 worldPos) {
+  vec3 base;
+  vec3 frac;
+  probeCell(worldPos, base, frac);
+  vec3 sum = vec3(0.0);
+  for (int c = 0; c < 8; c++) {
+    vec3 corner = vec3(float(c & 1), float((c >> 1) & 1), float((c >> 2) & 1));
+    vec3 axisWeight = mix(1.0 - frac, frac, corner);
+    float weight = axisWeight.x * axisWeight.y * axisWeight.z;
+    if (weight <= 0.0) continue;
+    sum += probeIrradiance(dir, probeLayer(base + corner)) * weight;
+  }
+  return sum;
+}
+
+/**
+ * The grid's reflection at a point: two probes along the axis the point is most between.
+ *
+ * **Two rather than eight, and the axis is chosen rather than fixed.** Sixteen fetches for a
+ * reflection is not affordable on the parts this engine targets, and a single probe pops as a
+ * smooth surface crosses a cell boundary. Blending along the axis with the largest betweenness
+ * removes the pop where it is largest for one extra pair of fetches; the other two axes take their
+ * nearest probe, where the switch happens at the point the blend would have been half and half.
+ *
+ * Full trilinear here is recorded as deferred rather than refused, with its reversal condition: a
+ * consumer measuring the remaining seam as their constraint.
+ */
+vec3 gridRadiance(vec3 dir, float lod, vec3 worldPos) {
+  vec3 base;
+  vec3 frac;
+  probeCell(worldPos, base, frac);
+  vec3 between = min(frac, 1.0 - frac);
+  vec3 nearest = base + step(vec3(0.5), frac);
+  vec3 low = nearest;
+  vec3 high = nearest;
+  float t = 0.0;
+  if (between.x >= between.y && between.x >= between.z) {
+    low.x = base.x;
+    high.x = base.x + 1.0;
+    t = frac.x;
+  } else if (between.y >= between.z) {
+    low.y = base.y;
+    high.y = base.y + 1.0;
+    t = frac.y;
+  } else {
+    low.z = base.z;
+    high.z = base.z + 1.0;
+    t = frac.z;
+  }
+  vec3 near = probeRadiance(dir, lod, probeLayer(low));
+  if (t <= 0.0) return near;
+  return mix(near, probeRadiance(dir, lod, probeLayer(high)), t);
+}
+#endif`;

package/dist/render/shaders/flat/surface.d.ts

@@ -0,0 +1,2 @@
+/** Grain and relief: the two terms that come from the surface rather than from the light. */
+export declare const SURFACE_GLSL = "float grainHash(vec3 p) {\n  p = fract(p * 0.1031);\n  p += dot(p, p.zyx + 31.32);\n  return fract((p.x + p.y) * p.z);\n}\n\nfloat grain(vec3 p) {\n  vec3 i = floor(p);\n  vec3 f = fract(p);\n  vec3 u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(\n      mix(grainHash(i + vec3(0.0, 0.0, 0.0)), grainHash(i + vec3(1.0, 0.0, 0.0)), u.x),\n      mix(grainHash(i + vec3(0.0, 1.0, 0.0)), grainHash(i + vec3(1.0, 1.0, 0.0)), u.x),\n      u.y\n    ),\n    mix(\n      mix(grainHash(i + vec3(0.0, 0.0, 1.0)), grainHash(i + vec3(1.0, 0.0, 1.0)), u.x),\n      mix(grainHash(i + vec3(0.0, 1.0, 1.0)), grainHash(i + vec3(1.0, 1.0, 1.0)), u.x),\n      u.y\n    ),\n    u.z\n  );\n}\n\n/**\n * A colour read as a height, for `uTextureRelief`.\n *\n * Luminance rather than three.js's red channel alone, because the image doing this job here is\n * the *colour* image and a red-only reading ties how tall a bump is to what colour it happens\n * to be \u2014 a rust streak on grey rock would stand proud of it for no reason a surface has. On the\n * greyscale tile a dedicated bump map usually is, the two agree exactly.\n *\n * Rec. 709 weights, matching `bloom.ts`'s own discussion of the same coefficients.\n */\nfloat surfaceHeight(vec3 rgb) {\n  return dot(rgb, vec3(0.2126, 0.7152, 0.0722));\n}\n";

package/dist/render/shaders/flat/surface.js

@@ -0,0 +1,40 @@
+/** Grain and relief: the two terms that come from the surface rather than from the light. */
+export const SURFACE_GLSL = `float grainHash(vec3 p) {
+  p = fract(p * 0.1031);
+  p += dot(p, p.zyx + 31.32);
+  return fract((p.x + p.y) * p.z);
+}
+
+float grain(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  vec3 u = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(
+      mix(grainHash(i + vec3(0.0, 0.0, 0.0)), grainHash(i + vec3(1.0, 0.0, 0.0)), u.x),
+      mix(grainHash(i + vec3(0.0, 1.0, 0.0)), grainHash(i + vec3(1.0, 1.0, 0.0)), u.x),
+      u.y
+    ),
+    mix(
+      mix(grainHash(i + vec3(0.0, 0.0, 1.0)), grainHash(i + vec3(1.0, 0.0, 1.0)), u.x),
+      mix(grainHash(i + vec3(0.0, 1.0, 1.0)), grainHash(i + vec3(1.0, 1.0, 1.0)), u.x),
+      u.y
+    ),
+    u.z
+  );
+}
+
+/**
+ * A colour read as a height, for \`uTextureRelief\`.
+ *
+ * Luminance rather than three.js's red channel alone, because the image doing this job here is
+ * the *colour* image and a red-only reading ties how tall a bump is to what colour it happens
+ * to be — a rust streak on grey rock would stand proud of it for no reason a surface has. On the
+ * greyscale tile a dedicated bump map usually is, the two agree exactly.
+ *
+ * Rec. 709 weights, matching \`bloom.ts\`'s own discussion of the same coefficients.
+ */
+float surfaceHeight(vec3 rgb) {
+  return dot(rgb, vec3(0.2126, 0.7152, 0.0722));
+}
+`;

package/dist/render/shaders/flock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Birds: two triangles each, circling on a path computed entirely in the vertex
+ * shader.
+ *
+ * No simulation, no CPU work per frame, no collision. A flock is scenery, and
+ * scenery that costs frame time is a bad trade — what it buys is the sense that
+ * the world exists without the player, which needs motion and silhouette, not
+ * behaviour.
+ */
+export declare const FLOCK_VERT = "#version 300 es\nlayout(location = 0) in vec2 aCorner;\nlayout(location = 1) in float aWing;\nlayout(location = 2) in float aIndex;\n\nuniform mat4 uViewProj;\nuniform vec3 uCenter;\nuniform float uRadius;\nuniform float uHeight;\nuniform float uSpeed;\nuniform float uTime;\nuniform float uCount;\nuniform float uScale;\n/** Horizontal wind, m/s. Birds hold station against it rather than riding it. */\nuniform vec2 uWind;\n\nout float vShade;\n\nvoid main() {\n  // Each bird gets its own orbit: radius, height and rate all vary with index,\n  // so the flock drifts apart and re-gathers instead of turning as one rigid\n  // ring \u2014 which is what a shared angle alone produces.\n  float id = aIndex;\n  /*\n   * Hashed from id + 1, and that +1 is a bug fix rather than a flourish.\n   *\n   * fract(sin(x) * k) has a fixed point at zero: sin(0) is 0, so bird 0 came out with spin\n   * and lift of exactly 0 while every other bird got a scattered value. Zero is not a\n   * middling result here, it is the floor of all three ranges at once \u2014 the innermost\n   * orbit of the whole flock, the lowest height and the slowest wingbeat. Measured on the\n   * storm scene: bird 0 orbited at 8.25 m while birds 1 to 33 spread over 8.34 to 15.72 m.\n   * One bird in every flock, in every scene, permanently unlike the rest.\n   */\n  float seed = id + 1.0;\n  float spin = fract(sin(seed * 12.9898) * 43758.5453);\n  float lift = fract(sin(seed * 78.233) * 24634.6345);\n\n  float radius = uRadius * (0.55 + spin * 0.5);\n  float rate = uSpeed * (0.8 + lift * 0.45) / max(radius, 0.001);\n  float angle = uTime * rate + id * 6.2831 / max(uCount, 1.0);\n\n  vec3 heading = vec3(-sin(angle), 0.0, cos(angle));\n\n  /*\n   * Birds are not leaves. They hold station against a wind rather than being\n   * carried off by it, so the wind does not translate them \u2014 it costs them\n   * ground speed when they turn into it and gives it back downwind, and it\n   * pushes the whole circuit slightly to leeward. The read is that they are\n   * working, which is the only reason a bird is interesting at this distance.\n   */\n  float into = -dot(normalize(heading.xz + vec2(1e-5)), uWind) * 0.06;\n  float driftAngle = angle + into;\n\n  vec3 centre = uCenter + vec3(\n    cos(driftAngle) * radius + uWind.x * 1.1,\n    uHeight * (0.7 + lift * 0.6) + sin(uTime * 0.6 + id) * 1.4,\n    sin(driftAngle) * radius + uWind.y * 1.1\n  );\n\n  // Wings beat about the bird's own travel direction, so the flap axis follows\n  // the turn rather than staying locked to the world.\n  vec3 forward = vec3(-sin(driftAngle), 0.0, cos(driftAngle));\n  vec3 side = normalize(cross(forward, vec3(0.0, 1.0, 0.0)));\n\n  // Harder into the wind: the beat rate rises with how much of the heading\n  // opposes it, which is what makes the effort legible without any simulation.\n  float effort = 1.0 + max(into, 0.0) * 22.0;\n  float beat = sin(uTime * (9.0 + spin * 4.0) * effort + id) * 0.5 + 0.5;\n  // aWing is 0 at the body and 1 at the tip, so only the tip rises.\n  float fold = aWing * beat * 0.55;\n\n  vec3 offset = side * (aCorner.x * uScale)\n    + forward * (aCorner.y * uScale * 0.6)\n    + vec3(0.0, fold * uScale, 0.0);\n\n  vec3 world = centre + offset;\n  // Silhouette only: a bird at this distance is a shape against the sky, and\n  // shading it properly would just make it grey.\n  vShade = 0.55 + beat * 0.25;\n  gl_Position = uViewProj * vec4(world, 1.0);\n}\n";
+export declare const FLOCK_FRAG = "#version 300 es\nprecision highp float;\n\nin float vShade;\nuniform vec3 uTint;\nout vec4 outColor;\n\nvoid main() {\n  outColor = vec4(uTint * vShade, 1.0);\n}\n";

package/dist/render/shaders/flock.js

@@ -0,0 +1,102 @@
+/**
+ * Birds: two triangles each, circling on a path computed entirely in the vertex
+ * shader.
+ *
+ * No simulation, no CPU work per frame, no collision. A flock is scenery, and
+ * scenery that costs frame time is a bad trade — what it buys is the sense that
+ * the world exists without the player, which needs motion and silhouette, not
+ * behaviour.
+ */
+export const FLOCK_VERT = `#version 300 es
+layout(location = 0) in vec2 aCorner;
+layout(location = 1) in float aWing;
+layout(location = 2) in float aIndex;
+
+uniform mat4 uViewProj;
+uniform vec3 uCenter;
+uniform float uRadius;
+uniform float uHeight;
+uniform float uSpeed;
+uniform float uTime;
+uniform float uCount;
+uniform float uScale;
+/** Horizontal wind, m/s. Birds hold station against it rather than riding it. */
+uniform vec2 uWind;
+
+out float vShade;
+
+void main() {
+  // Each bird gets its own orbit: radius, height and rate all vary with index,
+  // so the flock drifts apart and re-gathers instead of turning as one rigid
+  // ring — which is what a shared angle alone produces.
+  float id = aIndex;
+  /*
+   * Hashed from id + 1, and that +1 is a bug fix rather than a flourish.
+   *
+   * fract(sin(x) * k) has a fixed point at zero: sin(0) is 0, so bird 0 came out with spin
+   * and lift of exactly 0 while every other bird got a scattered value. Zero is not a
+   * middling result here, it is the floor of all three ranges at once — the innermost
+   * orbit of the whole flock, the lowest height and the slowest wingbeat. Measured on the
+   * storm scene: bird 0 orbited at 8.25 m while birds 1 to 33 spread over 8.34 to 15.72 m.
+   * One bird in every flock, in every scene, permanently unlike the rest.
+   */
+  float seed = id + 1.0;
+  float spin = fract(sin(seed * 12.9898) * 43758.5453);
+  float lift = fract(sin(seed * 78.233) * 24634.6345);
+
+  float radius = uRadius * (0.55 + spin * 0.5);
+  float rate = uSpeed * (0.8 + lift * 0.45) / max(radius, 0.001);
+  float angle = uTime * rate + id * 6.2831 / max(uCount, 1.0);
+
+  vec3 heading = vec3(-sin(angle), 0.0, cos(angle));
+
+  /*
+   * Birds are not leaves. They hold station against a wind rather than being
+   * carried off by it, so the wind does not translate them — it costs them
+   * ground speed when they turn into it and gives it back downwind, and it
+   * pushes the whole circuit slightly to leeward. The read is that they are
+   * working, which is the only reason a bird is interesting at this distance.
+   */
+  float into = -dot(normalize(heading.xz + vec2(1e-5)), uWind) * 0.06;
+  float driftAngle = angle + into;
+
+  vec3 centre = uCenter + vec3(
+    cos(driftAngle) * radius + uWind.x * 1.1,
+    uHeight * (0.7 + lift * 0.6) + sin(uTime * 0.6 + id) * 1.4,
+    sin(driftAngle) * radius + uWind.y * 1.1
+  );
+
+  // Wings beat about the bird's own travel direction, so the flap axis follows
+  // the turn rather than staying locked to the world.
+  vec3 forward = vec3(-sin(driftAngle), 0.0, cos(driftAngle));
+  vec3 side = normalize(cross(forward, vec3(0.0, 1.0, 0.0)));
+
+  // Harder into the wind: the beat rate rises with how much of the heading
+  // opposes it, which is what makes the effort legible without any simulation.
+  float effort = 1.0 + max(into, 0.0) * 22.0;
+  float beat = sin(uTime * (9.0 + spin * 4.0) * effort + id) * 0.5 + 0.5;
+  // aWing is 0 at the body and 1 at the tip, so only the tip rises.
+  float fold = aWing * beat * 0.55;
+
+  vec3 offset = side * (aCorner.x * uScale)
+    + forward * (aCorner.y * uScale * 0.6)
+    + vec3(0.0, fold * uScale, 0.0);
+
+  vec3 world = centre + offset;
+  // Silhouette only: a bird at this distance is a shape against the sky, and
+  // shading it properly would just make it grey.
+  vShade = 0.55 + beat * 0.25;
+  gl_Position = uViewProj * vec4(world, 1.0);
+}
+`;
+export const FLOCK_FRAG = `#version 300 es
+precision highp float;
+
+in float vShade;
+uniform vec3 uTint;
+out vec4 outColor;
+
+void main() {
+  outColor = vec4(uTint * vShade, 1.0);
+}
+`;

package/dist/render/shaders/fog.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The medium between the camera and everything it can see: haze in the air, and
+ * the water column when the camera is under it.
+ *
+ * One GLSL string rather than a copy in each program. Seven fragment shaders were
+ * carrying the same seven uniform declarations and the same four lines of fog, which
+ * is seven chances for the mesh under a slick to recede at a different rate than the
+ * slick does — and it had already happened: the oil film's own comment claimed *"the
+ * same fog every other pass applies"* while it ran a different curve.
+ */
+/**
+ * Air is **Beer–Lambert through a haze layer that thins with height**, water keeps its
+ * own squared law, and `uUnderwaterFactor` crossfades them across the surface.
+ *
+ * **Why the air law changed (2026-08-04).** It used to be `1 − exp(−(σd)²)`, the
+ * fixed-function `GL_EXP2` curve, whose optical depth grows with the *square* of
+ * distance — which is not an extinction law, it is a medium that gets denser the
+ * further you look. It saturates viciously: at the day-3 density it reached 50% at
+ * 63 m and **99.9% at 200 m**, so when the world grew from a 44 m band to a 232 m one
+ * the whole of a 200 m descent, the sea and the islands were a single flat wash of sky
+ * colour. Beer–Lambert spends the same near field over a far longer range — and it has
+ * a *non-zero gradient at zero distance*, where the squared law is flat, so the first
+ * twenty metres actually gain depth rather than lose it.
+ *
+ * **Why height matters.** Haze sits on the sea and thins upward; there is less air
+ * above you the higher you stand. That is the difference between looking along a valley
+ * and looking down a mountain, which is exactly the distinction this world acquired
+ * when it got tall. Density is `σ₀·exp(−(y − y₀)/H)`, and the optical depth along a ray
+ * is that integrated between the two endpoint heights — which collapses to the density
+ * at the eye times `(1 − e⁻ᵗ)/t`, with `t` the height climbed in scale heights. The eye
+ * density and `1/H` arrive precomputed from `bindAtmosphere`.
+ *
+ * `uFogEyeY` rather than `uCameraPos.y` because two of the seven programs (the plumes)
+ * never needed the camera position in their fragment stage, and a block that declares
+ * everything it uses can be pasted anywhere.
+ */
+export declare const FOG_GLSL = "\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n";

package/dist/render/shaders/fog.js

@@ -0,0 +1,98 @@
+/**
+ * The medium between the camera and everything it can see: haze in the air, and
+ * the water column when the camera is under it.
+ *
+ * One GLSL string rather than a copy in each program. Seven fragment shaders were
+ * carrying the same seven uniform declarations and the same four lines of fog, which
+ * is seven chances for the mesh under a slick to recede at a different rate than the
+ * slick does — and it had already happened: the oil film's own comment claimed *"the
+ * same fog every other pass applies"* while it ran a different curve.
+ */
+/**
+ * Air is **Beer–Lambert through a haze layer that thins with height**, water keeps its
+ * own squared law, and `uUnderwaterFactor` crossfades them across the surface.
+ *
+ * **Why the air law changed (2026-08-04).** It used to be `1 − exp(−(σd)²)`, the
+ * fixed-function `GL_EXP2` curve, whose optical depth grows with the *square* of
+ * distance — which is not an extinction law, it is a medium that gets denser the
+ * further you look. It saturates viciously: at the day-3 density it reached 50% at
+ * 63 m and **99.9% at 200 m**, so when the world grew from a 44 m band to a 232 m one
+ * the whole of a 200 m descent, the sea and the islands were a single flat wash of sky
+ * colour. Beer–Lambert spends the same near field over a far longer range — and it has
+ * a *non-zero gradient at zero distance*, where the squared law is flat, so the first
+ * twenty metres actually gain depth rather than lose it.
+ *
+ * **Why height matters.** Haze sits on the sea and thins upward; there is less air
+ * above you the higher you stand. That is the difference between looking along a valley
+ * and looking down a mountain, which is exactly the distinction this world acquired
+ * when it got tall. Density is `σ₀·exp(−(y − y₀)/H)`, and the optical depth along a ray
+ * is that integrated between the two endpoint heights — which collapses to the density
+ * at the eye times `(1 − e⁻ᵗ)/t`, with `t` the height climbed in scale heights. The eye
+ * density and `1/H` arrive precomputed from `bindAtmosphere`.
+ *
+ * `uFogEyeY` rather than `uCameraPos.y` because two of the seven programs (the plumes)
+ * never needed the camera position in their fragment stage, and a block that declares
+ * everything it uses can be pasted anywhere.
+ */
+export const FOG_GLSL = `
+uniform vec3 uFogColor;
+/** Extinction per metre **at the camera's own height**, not at the base. */
+uniform float uFogDensity;
+/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */
+uniform float uFogHeightFalloff;
+/** The camera's height, so a fragment's own height is one subtraction away. */
+uniform float uFogEyeY;
+uniform vec3 uUnderwaterColor;
+uniform float uUnderwaterFogDensity;
+uniform float uUnderwaterFactor;
+/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */
+uniform int uFogMode;
+/** Linear mode only: where haze begins, and where it is total. */
+uniform float uFogNear;
+uniform float uFogFar;
+
+/** What distance converges toward: the day's haze, or the water column. */
+vec3 mediumColor() {
+  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);
+}
+
+/**
+ * How much of a surface standing at height pointY, dist metres away, is lost to
+ * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.
+ */
+float mediumFog(float dist, float pointY) {
+  /*
+   * A depth ramp rather than a medium, for worlds authored against one.
+   *
+   * Beer-Lambert is the honest model and stays the default: it integrates something
+   * physically there, so extinction begins at the eye and never stops. A linear near/far
+   * fog is not that — it is a *look*, with a hard start distance before which the air is
+   * perfectly clear, and it is what the fixed-function pipeline offered and what several
+   * renderers still expose. Approximating one with the other is not a matter of tuning:
+   * matched at half occlusion, the exponential curve still lays haze over everything
+   * inside near, where the ramp lays none, and near-field colour desaturates toward the
+   * fog colour with nothing to show for it.
+   *
+   * Height falloff has no meaning here and is ignored: a ramp is defined on distance
+   * alone.
+   */
+  if (uFogMode == 1) {
+    float span = max(uFogFar - uFogNear, 1e-4);
+    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);
+    if (uUnderwaterFactor <= 0.0) return ramp;
+    float wetLinear = uUnderwaterFogDensity * dist;
+    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);
+  }
+
+  float t = (pointY - uFogEyeY) * uFogHeightFalloff;
+  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than
+  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.
+  float denom = abs(t) < 1e-4 ? 1e-4 : t;
+  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);
+  if (uUnderwaterFactor <= 0.0) return air;
+  // Water is its own medium and keeps its own curve, so crossing the surface
+  // changes nothing about how the water column reads.
+  float wet = uUnderwaterFogDensity * dist;
+  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);
+}
+`;

package/dist/render/shaders/fullscreen.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The vertex stage every full-viewport pass shares.
+ *
+ * One module because there is one right answer and three programs want it: the composite,
+ * the ambient-occlusion estimate and its blur. Copying it into each would be three places
+ * for the winding, the UV convention and the triangle-versus-quad decision to drift apart,
+ * and a post chain whose passes disagree about which way up the image is fails in a way that
+ * looks like every effect being wrong at once.
+ */
+/**
+ * A fullscreen triangle from `gl_VertexID` alone — no vertex buffer, no VAO contents.
+ *
+ * Three vertices covering the viewport beats two triangles: the shared diagonal of a quad
+ * makes some GPUs rasterise the seam twice, and a triangle has no seam.
+ */
+export declare const FULLSCREEN_VERT = "#version 300 es\nprecision highp float;\n\nout vec2 vUv;\n\nvoid main() {\n  // (-1,-1), (3,-1), (-1,3): a triangle whose clipped interior is exactly the viewport.\n  vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) * 2.0 - 1.0;\n  vUv = corner * 0.5 + 0.5;\n  gl_Position = vec4(corner, 0.0, 1.0);\n}\n";

package/dist/render/shaders/fullscreen.js

@@ -0,0 +1,27 @@
+/**
+ * The vertex stage every full-viewport pass shares.
+ *
+ * One module because there is one right answer and three programs want it: the composite,
+ * the ambient-occlusion estimate and its blur. Copying it into each would be three places
+ * for the winding, the UV convention and the triangle-versus-quad decision to drift apart,
+ * and a post chain whose passes disagree about which way up the image is fails in a way that
+ * looks like every effect being wrong at once.
+ */
+/**
+ * A fullscreen triangle from `gl_VertexID` alone — no vertex buffer, no VAO contents.
+ *
+ * Three vertices covering the viewport beats two triangles: the shared diagonal of a quad
+ * makes some GPUs rasterise the seam twice, and a triangle has no seam.
+ */
+export const FULLSCREEN_VERT = `#version 300 es
+precision highp float;
+
+out vec2 vUv;
+
+void main() {
+  // (-1,-1), (3,-1), (-1,3): a triangle whose clipped interior is exactly the viewport.
+  vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) * 2.0 - 1.0;
+  vUv = corner * 0.5 + 0.5;
+  gl_Position = vec4(corner, 0.0, 1.0);
+}
+`;

package/dist/render/shaders/generated/ambientOcclusion.wgsl.d.ts

@@ -0,0 +1,65 @@
+export declare const AO_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n    uDepthToViewZ: vec4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uAo_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uAo_s: sampler;\nvar<private> fragColor: f32;\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e22 = (*depth);\n    ndc = (1f - (_e22 * 2f));\n    let _e27 = unnamed.uDepthToViewZ[0u];\n    let _e28 = ndc;\n    let _e32 = unnamed.uDepthToViewZ[1u];\n    let _e36 = unnamed.uDepthToViewZ[2u];\n    let _e37 = ndc;\n    let _e41 = unnamed.uDepthToViewZ[3u];\n    return (((_e27 * _e28) + _e32) / ((_e36 * _e37) + _e41));\n}\n\nfn main_1() {\n    var centre: f32;\n    var param: f32;\n    var tolerance: f32;\n    var sum: f32;\n    var weight: f32;\n    var i: i32;\n    var uv: vec2<f32>;\n    var z: f32;\n    var param_1: f32;\n    var w: f32;\n    var local: f32;\n\n    let _e31 = vUv_1;\n    let _e32 = textureSampleLevel(uDepth_t, uDepth_s, _e31, 0f);\n    param = _e32.x;\n    let _e34 = viewZ_u0028_f1_u003b((&param));\n    centre = _e34;\n    let _e35 = centre;\n    tolerance = ((0.02f * abs(_e35)) + 0.0001f);\n    sum = 0f;\n    weight = 0f;\n    i = -3i;\n    loop {\n        let _e39 = i;\n        if (_e39 <= 4i) {\n            let _e41 = vUv_1;\n            let _e43 = unnamed.uStep;\n            let _e44 = i;\n            uv = (_e41 + (_e43 * f32(_e44)));\n            let _e48 = uv;\n            let _e49 = textureSampleLevel(uDepth_t, uDepth_s, _e48, 0f);\n            param_1 = _e49.x;\n            let _e51 = viewZ_u0028_f1_u003b((&param_1));\n            z = _e51;\n            let _e52 = z;\n            let _e53 = centre;\n            let _e56 = tolerance;\n            w = max(0f, (1f - (abs((_e52 - _e53)) / _e56)));\n            let _e60 = uv;\n            let _e61 = textureSampleLevel(uAo_t, uAo_s, _e60, 0f);\n            let _e63 = w;\n            let _e65 = sum;\n            sum = (_e65 + (_e61.x * _e63));\n            let _e67 = w;\n            let _e68 = weight;\n            weight = (_e68 + _e67);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e70 = i;\n            i = (_e70 + 1i);\n        }\n    }\n    let _e72 = weight;\n    if (_e72 > 0f) {\n        let _e74 = sum;\n        let _e75 = weight;\n        local = (_e74 / _e75);\n    } else {\n        let _e77 = vUv_1;\n        let _e78 = textureSampleLevel(uAo_t, uAo_s, _e77, 0f);\n        local = _e78.x;\n    }\n    let _e80 = local;\n    fragColor = _e80;\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export declare const AO_FRAG_WGSL = "struct Uniforms {\n    uProjScale: vec2<f32>,\n    uInvProjection: mat4x4<f32>,\n    uRadius: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uDepth_s: sampler;\nvar<private> fragColor: f32;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn viewPosition_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {\n    var clip: vec4<f32>;\n    var view: vec4<f32>;\n\n    let _e33 = (*uv);\n    let _e36 = ((_e33 * 2f) - vec2(1f));\n    let _e37 = (*depth);\n    clip = vec4<f32>(_e36.x, _e36.y, (1f - (_e37 * 2f)), 1f);\n    let _e44 = unnamed.uInvProjection;\n    let _e45 = clip;\n    view = (_e44 * _e45);\n    let _e47 = view;\n    let _e50 = view[3u];\n    return (_e47.xyz / vec3(_e50));\n}\n\nfn main_1() {\n    var stepX: vec2<f32>;\n    var stepY: vec2<f32>;\n    var depth_1: f32;\n    var p: vec3<f32>;\n    var param: vec2<f32>;\n    var param_1: f32;\n    var dpdx_: vec3<f32>;\n    var dpdy_: vec3<f32>;\n    var right: vec3<f32>;\n    var param_2: vec2<f32>;\n    var param_3: f32;\n    var left: vec3<f32>;\n    var param_4: vec2<f32>;\n    var param_5: f32;\n    var down: vec3<f32>;\n    var param_6: vec2<f32>;\n    var param_7: f32;\n    var up: vec3<f32>;\n    var param_8: vec2<f32>;\n    var param_9: f32;\n    var here: f32;\n    var edgeFloor: f32;\n    var rightGap: f32;\n    var leftGap: f32;\n    var downGap: f32;\n    var upGap: f32;\n    var n: vec3<f32>;\n    var reach: vec2<f32>;\n    var tile: f32;\n    var turn: f32;\n    var sum: f32;\n    var i: i32;\n    var t: f32;\n    var angle: f32;\n    var uv_1: vec2<f32>;\n    var sampled: f32;\n    var v: vec3<f32>;\n    var param_10: vec2<f32>;\n    var param_11: f32;\n    var vv: f32;\n\n    let _e69 = vUv_1;\n    let _e70 = dpdx(_e69);\n    stepX = _e70;\n    let _e71 = vUv_1;\n    let _e72 = dpdy(_e71);\n    stepY = _e72;\n    let _e73 = vUv_1;\n    let _e74 = textureSampleLevel(uDepth_t, uDepth_s, _e73, 0f);\n    depth_1 = _e74.x;\n    let _e76 = vUv_1;\n    param = _e76;\n    let _e77 = depth_1;\n    param_1 = _e77;\n    let _e78 = viewPosition_u0028_vf2_u003b_f1_u003b((&param), (&param_1));\n    p = _e78;\n    let _e79 = p;\n    let _e80 = dpdx(_e79);\n    dpdx_ = _e80;\n    let _e81 = p;\n    let _e82 = dpdy(_e81);\n    dpdy_ = _e82;\n    let _e83 = depth_1;\n    if (_e83 <= 0f) {\n        fragColor = 1f;\n        return;\n    }\n    let _e85 = vUv_1;\n    let _e86 = stepX;\n    let _e88 = vUv_1;\n    let _e89 = stepX;\n    let _e91 = textureSampleLevel(uDepth_t, uDepth_s, (_e88 + _e89), 0f);\n    param_2 = (_e85 + _e86);\n    param_3 = _e91.x;\n    let _e93 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_2), (&param_3));\n    right = _e93;\n    let _e94 = vUv_1;\n    let _e95 = stepX;\n    let _e97 = vUv_1;\n    let _e98 = stepX;\n    let _e100 = textureSampleLevel(uDepth_t, uDepth_s, (_e97 - _e98), 0f);\n    param_4 = (_e94 - _e95);\n    param_5 = _e100.x;\n    let _e102 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_4), (&param_5));\n    left = _e102;\n    let _e103 = vUv_1;\n    let _e104 = stepY;\n    let _e106 = vUv_1;\n    let _e107 = stepY;\n    let _e109 = textureSampleLevel(uDepth_t, uDepth_s, (_e106 + _e107), 0f);\n    param_6 = (_e103 + _e104);\n    param_7 = _e109.x;\n    let _e111 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_6), (&param_7));\n    down = _e111;\n    let _e112 = vUv_1;\n    let _e113 = stepY;\n    let _e115 = vUv_1;\n    let _e116 = stepY;\n    let _e118 = textureSampleLevel(uDepth_t, uDepth_s, (_e115 - _e116), 0f);\n    param_8 = (_e112 - _e113);\n    param_9 = _e118.x;\n    let _e120 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));\n    up = _e120;\n    let _e122 = p[2u];\n    here = -(_e122);\n    let _e124 = here;\n    edgeFloor = (0.05f * _e124);\n    let _e127 = right[2u];\n    let _e129 = here;\n    rightGap = abs((-(_e127) - _e129));\n    let _e133 = left[2u];\n    let _e135 = here;\n    leftGap = abs((-(_e133) - _e135));\n    let _e139 = down[2u];\n    let _e141 = here;\n    downGap = abs((-(_e139) - _e141));\n    let _e145 = up[2u];\n    let _e147 = here;\n    upGap = abs((-(_e145) - _e147));\n    let _e150 = rightGap;\n    let _e151 = leftGap;\n    let _e153 = edgeFloor;\n    if (_e150 > ((_e151 * 8f) + _e153)) {\n        let _e156 = p;\n        let _e157 = left;\n        dpdx_ = (_e156 - _e157);\n    } else {\n        let _e159 = leftGap;\n        let _e160 = rightGap;\n        let _e162 = edgeFloor;\n        if (_e159 > ((_e160 * 8f) + _e162)) {\n            let _e165 = right;\n            let _e166 = p;\n            dpdx_ = (_e165 - _e166);\n        }\n    }\n    let _e168 = downGap;\n    let _e169 = upGap;\n    let _e171 = edgeFloor;\n    if (_e168 > ((_e169 * 8f) + _e171)) {\n        let _e174 = p;\n        let _e175 = up;\n        dpdy_ = (_e174 - _e175);\n    } else {\n        let _e177 = upGap;\n        let _e178 = downGap;\n        let _e180 = edgeFloor;\n        if (_e177 > ((_e178 * 8f) + _e180)) {\n            let _e183 = down;\n            let _e184 = p;\n            dpdy_ = (_e183 - _e184);\n        }\n    }\n    let _e186 = dpdx_;\n    let _e187 = dpdy_;\n    n = normalize(cross(_e186, _e187));\n    let _e190 = n;\n    let _e191 = p;\n    if (dot(_e190, _e191) > 0f) {\n        let _e194 = n;\n        n = -(_e194);\n    }\n    let _e197 = unnamed.uRadius;\n    let _e199 = unnamed.uProjScale;\n    let _e203 = p[2u];\n    reach = min((((_e199 * _e197) * 0.5f) / vec2(max(-(_e203), 0.001f))), vec2<f32>(0.06f, 0.06f));\n    let _e210 = gl_FragCoord_1[0u];\n    let _e216 = gl_FragCoord_1[1u];\n    tile = ((_e210 - (floor((_e210 / 4f)) * 4f)) + (4f * (_e216 - (floor((_e216 / 4f)) * 4f))));\n    let _e223 = tile;\n    turn = (_e223 * 0.3926991f);\n    sum = 0f;\n    i = 0i;\n    loop {\n        let _e225 = i;\n        if (_e225 < 12i) {\n            let _e227 = i;\n            t = ((f32(_e227) + 0.5f) / 12f);\n            let _e231 = turn;\n            let _e232 = i;\n            angle = (_e231 + (f32(_e232) * 2.3999631f));\n            let _e236 = vUv_1;\n            let _e237 = angle;\n            let _e239 = angle;\n            let _e242 = t;\n            let _e245 = reach;\n            uv_1 = (_e236 + ((vec2<f32>(cos(_e237), sin(_e239)) * sqrt(_e242)) * _e245));\n            let _e248 = uv_1;\n            let _e249 = textureSampleLevel(uDepth_t, uDepth_s, _e248, 0f);\n            sampled = _e249.x;\n            let _e251 = sampled;\n            if (_e251 <= 0f) {\n                continue;\n            }\n            let _e253 = uv_1;\n            param_10 = _e253;\n            let _e254 = sampled;\n            param_11 = _e254;\n            let _e255 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_10), (&param_11));\n            let _e256 = p;\n            v = (_e255 - _e256);\n            let _e258 = v;\n            let _e259 = v;\n            vv = dot(_e258, _e259);\n            let _e261 = vv;\n            let _e263 = unnamed.uRadius;\n            let _e265 = unnamed.uRadius;\n            if (_e261 > (_e263 * _e265)) {\n                continue;\n            }\n            let _e268 = v;\n            let _e269 = n;\n            let _e272 = p[2u];\n            let _e277 = vv;\n            let _e280 = sum;\n            sum = (_e280 + (max(0f, (dot(_e268, _e269) - (0.004f * -(_e272)))) / (_e277 + 0.01f)));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e282 = i;\n            i = (_e282 + 1i);\n        }\n    }\n    let _e285 = unnamed.uRadius;\n    let _e287 = sum;\n    fragColor = clamp((1f - (((2f * _e285) * _e287) / 12f)), 0f, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n    let _e5 = fragColor;\n    return _e5;\n}\n";
+/**
+ * What the transform assigned, so the renderer binds the same numbers.
+ *
+ * A permuted shader has one entry per variant, keyed as `FLAT_FRAG_WGSL` is.
+ */
+export declare const AMBIENTOCCLUSION_BINDINGS: {
+    readonly AO_BLUR_FRAG: {
+        readonly uniforms: 1;
+        readonly uniformSize: 32;
+        readonly fields: {
+            readonly uStep: {
+                readonly offset: 0;
+                readonly size: 8;
+                readonly type: "vec2";
+            };
+            readonly uDepthToViewZ: {
+                readonly offset: 16;
+                readonly size: 16;
+                readonly type: "vec4";
+            };
+        };
+        readonly textures: {
+            readonly uAo: {
+                readonly texture: 32;
+                readonly sampler: 33;
+                readonly type: "sampler2D";
+            };
+            readonly uDepth: {
+                readonly texture: 34;
+                readonly sampler: 35;
+                readonly type: "sampler2D";
+            };
+        };
+    };
+    readonly AO_FRAG: {
+        readonly uniforms: 1;
+        readonly uniformSize: 96;
+        readonly fields: {
+            readonly uProjScale: {
+                readonly offset: 0;
+                readonly size: 8;
+                readonly type: "vec2";
+            };
+            readonly uInvProjection: {
+                readonly offset: 16;
+                readonly size: 64;
+                readonly type: "mat4";
+            };
+            readonly uRadius: {
+                readonly offset: 80;
+                readonly size: 4;
+                readonly type: "float";
+            };
+        };
+        readonly textures: {
+            readonly uDepth: {
+                readonly texture: 32;
+                readonly sampler: 33;
+                readonly type: "sampler2D";
+            };
+        };
+    };
+};