@driftengine/core 4.5.0 → 4.6.0

package/dist/render/recon/resolve.js

@@ -30,6 +30,29 @@
  *    the render read bicubically fills the gap. The history keeps colour and weight; the picture shown
  *    is it sharpened.
  *
+ * **And the temporal resolve's anti-flicker, where the caller carries its records** (`temporalAa.ts`
+ * says why it works and what it gives up). A thread finer than a render texel is caught in some
+ * phases of the jitter and missed in others, and in a phase that misses it the nine texels can all
+ * miss it: the box collapses onto what is behind, the history is clipped out, and a still picture
+ * flashes at every fine edge each period. A still camera over a still scene gathers every pixel the
+ * same way each period, so each pixel keeps a record of this frame's gathered luma over the period,
+ * and once two periods running have repeated its box widens by its own spread and it keeps more of
+ * its history. **The record stays at the pixel rather than following the reprojection**, because the
+ * proof is only ever for a pixel that has not moved; it starts over wherever the history did not
+ * survive, and is forgotten in proportion to motion.
+ *
+ * **And a still pixel whose depth has been seen to swing is not a disocclusion.** A rail finer than
+ * a texel in front of a wall is caught in some phases and missed in others, so last frame can hold
+ * the wall where this frame holds the rail with nothing moved — and the depth test threw the history
+ * away, leaving the record nothing to keep. So each pixel also keeps the largest relative miss of
+ * last frame's depth it has seen lately, kept whatever the test says, and while still its tolerance
+ * widens to `DEPTH_SWING_WIDTH` of it — the temporal resolve's answer to a crack of light round a
+ * door, as a held peak rather than its running mean: a rail caught in one phase of eighteen misses
+ * once a period, and a mean has worn that miss down to a thirtieth by the next. **What it gives up**
+ * is the depth test's word at such a pixel while still: a surface arriving there inside the swing
+ * keeps the history, and the neighbourhood clip, which the unproven sample of an arrival leaves
+ * unwidened, is what takes it out.
+ *
  * **Conventions.** Images are rows from `v = 0` upward. Depths are clip depths in the matrices'
  * convention, OpenGL's here — the nearest is the smallest — and the renderer converts its reversed
  * buffer before a sample reaches this arithmetic, as the temporal resolve already does.
@@ -37,6 +60,7 @@
 import { clipToBox, rgbToYCoCg, varianceBox, yCoCgToRgb } from './clamp.js';
 import { disocclusionWeight, normalFromPositions, planarity, surfaceSlope, worldPositionFromDepth, } from './disocclusion.js';
 import { sampleBilinear, sampleHistoryBicubic5 } from './reproject.js';
+import { TEMPORAL_FLICKER, flickerBlend, flickerRule, flickerWidening, freshFlicker, nextFlicker, stillness, } from '../temporalAa.js';
 /**
  * A tenth of each frame kept, as the temporal resolve keeps; a box of a standard deviation and a
  * quarter; a light sharpen. At two thirds of the output a side.
@@ -98,6 +122,12 @@ export function reconstructionWeight(dx, dy) {
  * pixel away.
  */
 export const CONFIDENT_WEIGHT = 1;
+/**
+ * How many of its held depth swings a still pixel's depth test tolerates. The peak halves over a
+ * period, so the frame before the next once-a-period miss holds just over half of it: tolerating
+ * twice the peak passes that miss outright, and three leaves the same room again.
+ */
+export const DEPTH_SWING_WIDTH = 3;
 const SAMPLE = new Float32Array(3);
 const GATHERED = new Float64Array(3);
 const HISTORY = new Float32Array(4);
@@ -113,6 +143,37 @@ const UP = new Float64Array(3);
 const NORMAL = new Float64Array(3);
 const PREVIOUS_NORMAL = new Float64Array(3);
 const CLIP = new Float64Array(4);
+/** The last frame's reprojection, derived once a frame rather than once a pixel. */
+const REPROJECTION = new Float64Array(16);
+let reprojected = null;
+/** `frame.reprojection`, or the product of its two matrices, multiplied once per frame. */
+function reprojectionOf(frame) {
+    if (frame.reprojection !== undefined)
+        return frame.reprojection;
+    if (reprojected !== frame) {
+        reprojected = frame;
+        const a = frame.previousViewProj;
+        const b = frame.inverseViewProj;
+        for (let c = 0; c < 4; c += 1) {
+            for (let r = 0; r < 4; r += 1) {
+                let sum = 0;
+                for (let k = 0; k < 4; k += 1)
+                    sum += a[k * 4 + r] * b[c * 4 + k];
+                REPROJECTION[c * 4 + r] = sum;
+            }
+        }
+    }
+    return REPROJECTION;
+}
+const HELD = { spread: 0, sum: 0, mean: 0, repeated: 0 };
+const CARRIED = { spread: 0, sum: 0, mean: 0, repeated: 0 };
+/** How far, in output pixels, the last `historyWeight` found its surface had moved. */
+let moved = 0;
+/** How far, relative, last frame's depth missed the one expected there; -1 where nothing was held. */
+let missed = -1;
+/** The rule for the last period asked for, kept: one is made per period, not per pixel. */
+let rulePhases = 0;
+let rule = TEMPORAL_FLICKER;
 function clampTexel(value, size) {
     return value < 0 ? 0 : value >= size ? size - 1 : value;
 }
@@ -184,7 +245,8 @@ function normalAt(depths, inverse, jitter, eye, width, height, x, y, out) {
  * was behind last frame's eye or off its picture, and otherwise what it gathered, scaled by whether it
  * is the same surface. Reads `HISTORY`; writes the history's colour there.
  */
-function historyWeight(frame, u, v, dx, dy) {
+function historyWeight(frame, u, v, dx, dy, swing) {
+    missed = -1;
     if (!frame.hasHistory)
         return 0;
     const rw = frame.renderWidth;
@@ -199,27 +261,45 @@ function historyWeight(frame, u, v, dx, dy) {
         expected = frame.motion[flagAt + 2];
     }
     else {
-        if (worldAt(frame.depth, frame.inverseViewProj, frame.jitter, rw, rh, dx, dy, WORLD) <= 0) {
+        /*
+         * **Through one matrix, last frame's view-projection times this frame's inverse**, rather than
+         * out to a world position and back. The two are the same arithmetic in exact numbers; in single
+         * precision the round trip is not the identity — a near plane a quarter of a metre from a far one
+         * five kilometres off — and a still camera measured a few hundredths of a pixel of motion growing
+         * out from the middle of the frame, which crept every still history and kept every pixel from
+         * the anti-flicker's stillness. The product is taken where the precision is (`reprojection`),
+         * and for a still camera it is the identity.
+         */
+        const du = (dx + 0.5 - frame.jitter[0]) / rw;
+        const dv = (dy + 0.5 - frame.jitter[1]) / rh;
+        const x = du * 2 - 1;
+        const y = dv * 2 - 1;
+        const z = frame.depth[dy * rw + dx];
+        const inverse = frame.inverseViewProj;
+        /* The homogeneous w of the world position: none, or behind the eye, is no surface. */
+        const hw = inverse[3] * x +
+            inverse[7] * y +
+            inverse[11] * z +
+            inverse[15];
+        if (!(hw > 1e-12))
             return 0;
-        }
-        const m = frame.previousViewProj;
+        const m = reprojectionOf(frame);
         for (let r = 0; r < 4; r += 1) {
             CLIP[r] =
-                m[r] * WORLD[0] +
-                    m[4 + r] * WORLD[1] +
-                    m[8 + r] * WORLD[2] +
+                m[r] * x +
+                    m[4 + r] * y +
+                    m[8 + r] * z +
                     m[12 + r];
         }
         /*
          * A surface behind last frame's eye has a w that is not positive: the disocclusion trusts no
          * such depth, so it needs no refusal of its own here.
          */
-        expected = CLIP[3];
-        const du = (dx + 0.5 - frame.jitter[0]) / rw;
-        const dv = (dy + 0.5 - frame.jitter[1]) / rh;
-        mu = (CLIP[0] / expected) * 0.5 + 0.5 - du;
-        mv = (CLIP[1] / expected) * 0.5 + 0.5 - dv;
+        expected = CLIP[3] / hw;
+        mu = (CLIP[0] / CLIP[3]) * 0.5 + 0.5 - du;
+        mv = (CLIP[1] / CLIP[3]) * 0.5 + 0.5 - dv;
     }
+    moved = Math.hypot(mu * frame.outputWidth, mv * frame.outputHeight);
     const pu = u + mu;
     const pv = v + mv;
     if (!(pu >= 0 && pu <= 1 && pv >= 0 && pv <= 1))
@@ -284,14 +364,18 @@ function historyWeight(frame, u, v, dx, dy) {
             NORMAL[2] * PREVIOUS_NORMAL[2];
         normalDot = 1 - planar * (1 - cosine);
     }
-    const trust = disocclusionWeight(expected, held, Math.hypot(mu, mv), normalDot, frame.disocclusion, slope);
+    if (held > 0 && expected > 0)
+        missed = Math.abs(held - expected) / expected;
+    /* A still pixel's own depth swing, as wide as the anti-flicker's box: see the header. */
+    const swung = swing > 0 ? DEPTH_SWING_WIDTH * swing * stillness(moved) : 0;
+    const trust = disocclusionWeight(expected, held, Math.hypot(mu, mv), normalDot, frame.disocclusion, slope + swung);
     return HISTORY[3] * trust;
 }
 /**
  * One output pixel: the history's next colour, before sharpening, and the weight it has gathered —
- * four values into `out`.
+ * four values into `out` — and, where the frame carries records, the pixel's next one into `record`.
  */
-export function resolvePixel(frame, ox, oy, out) {
+export function resolvePixel(frame, ox, oy, out, record, swingOut) {
     const rw = frame.renderWidth;
     const rh = frame.renderHeight;
     const ow = frame.outputWidth;
@@ -339,8 +423,57 @@ export function resolvePixel(frame, ox, oy, out) {
     for (let c = 0; c < 3; c += 1)
         GATHERED[c] = GATHERED[c] / gathered;
     /* 3 and 4. The history, and the weight it still deserves. */
-    const cap = (1 - frame.quality.alpha) / frame.quality.alpha;
-    const kept = Math.min(cap, historyWeight(frame, u, v, dx, dy));
+    const alpha = frame.quality.alpha;
+    const records = frame.flicker;
+    const anti = records !== undefined && records !== null;
+    if (anti) {
+        const phases = frame.flickerPhases ?? 0;
+        if (phases !== rulePhases) {
+            rulePhases = phases;
+            rule = phases > 0 ? flickerRule(phases) : TEMPORAL_FLICKER;
+        }
+    }
+    const swings = frame.depthSwing;
+    const swing = anti && swings !== undefined && swings !== null ? swings[oy * ow + ox] : 0;
+    const weight = historyWeight(frame, u, v, dx, dy, swing);
+    let cap = (1 - alpha) / alpha;
+    /* The anti-flicker: a proven pixel's box widened by its spread, and more of its history kept. */
+    if (anti) {
+        const sample = GATHERED[0] * 0.2126 +
+            GATHERED[1] * 0.7152 +
+            GATHERED[2] * 0.0722;
+        const at = (oy * ow + ox) * 4;
+        if (weight > 0) {
+            HELD.spread = records[at];
+            HELD.sum = records[at + 1];
+            HELD.mean = records[at + 2];
+            HELD.repeated = records[at + 3];
+        }
+        else {
+            freshFlicker(HELD, sample, rule);
+        }
+        const still = weight > 0 ? stillness(moved) : 0;
+        const widen = flickerWidening(HELD, sample, still, rule);
+        for (let c = 0; c < 3; c += 1) {
+            LOW[c] = LOW[c] - widen;
+            HIGH[c] = HIGH[c] + widen;
+        }
+        const keep = flickerBlend(1 - alpha, HELD, sample, still, rule);
+        cap = keep / (1 - keep);
+        nextFlicker(CARRIED, HELD, sample, still, frame.periodStart === true, rule);
+        if (record !== undefined) {
+            record[0] = CARRIED.spread;
+            record[1] = CARRIED.sum;
+            record[2] = CARRIED.mean;
+            record[3] = CARRIED.repeated;
+        }
+        /* The peak carried on, halving over a period, whatever the test said; none where nothing was
+           held to miss. */
+        if (swingOut !== undefined) {
+            swingOut[0] = missed >= 0 ? Math.max(missed, swing * 0.5 ** rule.memory) : 0;
+        }
+    }
+    const kept = Math.min(cap, weight);
     /* 5. Clipped, mixed by weight, and the gaps filled from the render. */
     const total = kept + gathered;
     if (kept > 0) {
@@ -359,6 +492,8 @@ export function resolvePixel(frame, ox, oy, out) {
     out[3] = total;
 }
 const TAP = new Float32Array(4);
+const RECORD = new Float32Array(4);
+const SWING = new Float32Array(1);
 const CENTRE = new Float32Array(4);
 const AROUND = new Float32Array(12);
 const SHOWN = new Float32Array(3);
@@ -370,15 +505,21 @@ const OFFSETS = [
 ];
 /**
  * The whole frame: the next history into `history`, four floats a pixel, and the picture shown into
- * `shown`, three — the history sharpened against the four direct neighbours it has just been given.
+ * `shown`, three — the history sharpened against the four direct neighbours it has just been given —
+ * and, where the frame carries records, the next ones into `records`, four floats a pixel, and the
+ * next depth swings into `swings`, one.
  */
-export function resolveFrame(frame, history, shown) {
+export function resolveFrame(frame, history, shown, records, swings) {
     const ow = frame.outputWidth;
     const oh = frame.outputHeight;
     for (let y = 0; y < oh; y += 1) {
         for (let x = 0; x < ow; x += 1) {
-            resolvePixel(frame, x, y, TAP);
+            resolvePixel(frame, x, y, TAP, RECORD, SWING);
             history.set(TAP, (y * ow + x) * 4);
+            if (records !== undefined)
+                records.set(RECORD, (y * ow + x) * 4);
+            if (swings !== undefined)
+                swings[y * ow + x] = SWING[0];
         }
     }
     for (let y = 0; y < oh; y += 1) {

package/dist/render/rendererHarness.js

@@ -29,6 +29,10 @@ export function recordingGl(options = {}) {
     const programFragments = new WeakMap();
     const calls = [];
     const constants = {
+        /* The canvas's size, as a real context reports its drawing buffer; a function here made every
+           jitter and every per-pixel offset divided by it a NaN. */
+        drawingBufferWidth: 640,
+        drawingBufferHeight: 480,
         ACTIVE_UNIFORMS: 0x8b86,
         ACTIVE_ATTRIBUTES: 0x8b89,
         COMPILE_STATUS: 0x8b81,

package/dist/render/sceneTarget.d.ts

@@ -293,6 +293,8 @@ export declare class SceneTarget {
         /** The projection's x and y scales, which turn a world radius into a screen one. */
         readonly projScale: Float32Array;
         readonly invProjection: Float32Array;
+        /** Where the frame's jitter put the occlusion, in uv: see the shader's `uAoOffset`. */
+        readonly offset?: Float32Array;
     }, bloom?: {
         readonly strength: number;
         /** In scene units, which is why this wants `keepsRange`. See `BloomPass`. */

package/dist/render/sceneTarget.js

@@ -834,6 +834,8 @@ export class SceneTarget {
         gl.bindTexture(gl.TEXTURE_2D, aoTexture ?? scene);
         gl.uniform1i(this.uniforms['uAo'] ?? null, 2);
         gl.uniform1f(this.uniforms['uAoStrength'] ?? null, aoTexture === null ? 0 : (ao?.strength ?? 0));
+        const offset = ao?.offset;
+        gl.uniform2f(this.uniforms['uAoOffset'] ?? null, offset?.[0] ?? 0, offset?.[1] ?? 0);
         /* Bloom on its own unit, and the placeholder for the same reason as the one above: a
            driver may fetch a texture's descriptor before it evaluates the branch that skips the
            read, and an incomplete texture is not a thing to hand it. */

package/dist/render/shaders/depth.js

@@ -63,14 +63,15 @@ ${CHANNEL_BEND}
  * uniforms declared after every other, so no field of the plain variant moves and a binder written
  * against it stays right for this one; and two outputs after vLightPosition, which keeps location 0.
  */
-layout(location = 5) in vec2 aUv;
+layout(location = 5) in vec3 aUv;
 uniform vec2 uUvScale;
 uniform float uAlphaCutout;
 #endif
 
 out vec4 vLightPosition;
 #if CUTOUT
-out vec2 vUv;
+/* The texture coordinate and, in z, the texture-array layer the face wears. */
+out vec3 vUv;
 flat out float vAlphaCutout;
 #endif
 #if GLASS
@@ -102,7 +103,7 @@ void main() {
   vLightPosition = uLightViewProj * vec4(bent, world.w);
   gl_Position = vLightPosition;
 #if CUTOUT
-  vUv = aUv * uUvScale;
+  vUv = vec3(aUv.xy * uUvScale, aUv.z);
   vAlphaCutout = uAlphaCutout;
 #endif
 #if GLASS
@@ -168,16 +169,17 @@ void main() {
 export const DEPTH_CUTOUT_FRAG = `#version 300 es
 precision highp float;
 in vec4 vLightPosition;
-in vec2 vUv;
+in vec3 vUv;
 flat in float vAlphaCutout;
 
 uniform highp sampler2DArray uPreviousShadowMap;
 uniform int uPeelShadowLayer;
-uniform highp sampler2D uCutoutMap;
+uniform highp sampler2DArray uCutoutMap;
 ${CUTOUT_COVERAGE_GLSL}
 void main() {
   /* Credited for its mip level as the surface's own test is, so a leaf casts the shape it draws. */
-  float alpha = cutoutAlpha(texture(uCutoutMap, vUv).a, vUv * vec2(textureSize(uCutoutMap, 0)));
+  vec3 at = vec3(vUv.xy, floor(vUv.z + 0.5));
+  float alpha = cutoutAlpha(texture(uCutoutMap, at).a, vUv.xy * vec2(textureSize(uCutoutMap, 0).xy));
   if (uPeelShadowLayer != 0) {
     vec3 p = vLightPosition.xyz / vLightPosition.w;
     vec2 uv = p.xy * 0.5 + 0.5;
@@ -237,19 +239,20 @@ ${GLASS_TINT_BODY}
 export const GLASS_TINT_CUTOUT_FRAG = `#version 300 es
 precision highp float;
 in vec4 vLightPosition;
-in vec2 vUv;
+in vec3 vUv;
 flat in float vAlphaCutout;
 in vec3 vGlassWorld;
 
 uniform vec4 uGlassPane;
 uniform vec4 uGlassLight;
-uniform highp sampler2D uCutoutMap;
+uniform highp sampler2DArray uCutoutMap;
 ${CUTOUT_COVERAGE_GLSL}
 out vec4 outTint;
 
 void main() {
   /* First, in uniform control flow, as the depth cutout samples it. */
-  float alpha = cutoutAlpha(texture(uCutoutMap, vUv).a, vUv * vec2(textureSize(uCutoutMap, 0)));
+  vec3 at = vec3(vUv.xy, floor(vUv.z + 0.5));
+  float alpha = cutoutAlpha(texture(uCutoutMap, at).a, vUv.xy * vec2(textureSize(uCutoutMap, 0).xy));
 ${GLASS_TINT_BODY}
   if (alpha < vAlphaCutout) discard;
 }

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

@@ -26,4 +26,4 @@
  * `textureLod` throughout, by the 2026-08-07 rule: this is reached through branches no compiler can
  * prove uniform. Both samplers are declared `highp` because GLSL ES gives 3D samplers no default.
  */
-export declare const DRIFT_LIGHT_GLSL = "\n/** x how much of the summed light is in the frame (0 off), y the radius, z the band, w the scale. */\nuniform vec4 uDriftLight;\n/** xyz the first brick's first sample; w metres between samples, a third of a brick. */\nuniform vec4 uDriftLightOrigin;\nuniform highp usampler3D uDriftLightIndex;  // wgsl:share shadow\nuniform highp sampler3D uDriftLightAtlas;\n\n/** The share of this pixel's field light the volume stands in for: 0 inside the radius, 1 past it. */\nfloat driftLightShare(vec3 world) {\n  if (uDriftLight.x <= 0.0) return 0.0;\n  float away = distance(world, uCameraPos);\n  return smoothstep(uDriftLight.y - uDriftLight.z, uDriftLight.y, away) * uDriftLight.x;\n}\n\n/** The summed light arriving on a surface at `world` facing `n`. */\nvec3 driftLightIrradiance(vec3 world, vec3 n) {\n  float spacing = uDriftLightOrigin.w;\n  vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / (3.0 * spacing);\n  ivec3 cell = ivec3(floor(at));\n  if (any(lessThan(cell, ivec3(0))) || any(greaterThanEqual(cell, textureSize(uDriftLightIndex, 0)))) {\n    return vec3(0.0);\n  }\n  uint id = texelFetch(uDriftLightIndex, cell, 0).r;\n  if (id == 0u) return vec3(0.0);\n  /* A brick is eight texels across (its light block, then its direction block) and four up and deep. */\n  ivec3 size = textureSize(uDriftLightAtlas, 0);\n  int brick = int(id) - 1;\n  int across = size.x / 8;\n  int down = size.y / 4;\n  vec3 corner = vec3(\n    float((brick % across) * 8),\n    float(((brick / across) % down) * 4),\n    float((brick / (across * down)) * 4)\n  );\n  vec3 texel = 1.0 / vec3(size);\n  vec3 inside = (at - vec3(cell)) * 3.0 + 0.5;\n  vec4 light = textureLod(uDriftLightAtlas, (corner + inside) * texel, 0.0);\n  if (light.a < 1e-3) return vec3(0.0);\n  vec4 toward = textureLod(uDriftLightAtlas, (corner + vec3(4.0, 0.0, 0.0) + inside) * texel, 0.0);\n  vec3 arriving = light.rgb / light.a;\n  vec3 from = toward.xyz / light.a;\n  /* Lambert for a single light, a quarter for light arriving from everywhere: see `bake.ts`. */\n  float facing = max(dot(n, from), 0.0) + (1.0 - min(length(from), 1.0)) * 0.25;\n  return arriving * facing;\n}\n";
+export declare const DRIFT_LIGHT_GLSL = "\n/** x how much of the summed light is in the frame (0 off), y the radius, z the band, w the scale. */\nuniform vec4 uDriftLight;\n/** xyz the first sample; w metres between samples \u2014 a third of a brick, or negated for a dense volume. */\nuniform vec4 uDriftLightOrigin;\nuniform highp usampler3D uDriftLightIndex;  // wgsl:share shadow\nuniform highp sampler3D uDriftLightAtlas;\n\n/** The share of this pixel's field light the volume stands in for: 0 inside the radius, 1 past it. */\nfloat driftLightShare(vec3 world) {\n  if (uDriftLight.x <= 0.0) return 0.0;\n  float away = distance(world, uCameraPos);\n  return smoothstep(uDriftLight.y - uDriftLight.z, uDriftLight.y, away) * uDriftLight.x;\n}\n\n/**\n * A sample's light and direction turned into the light on a surface facing `n`: Lambert for a\n * single light, a quarter for light arriving from everywhere (see `bake.ts`). One statement for\n * both kinds of volume.\n */\nvec3 driftLightFacing(vec4 light, vec4 toward, vec3 n) {\n  vec3 arriving = light.rgb / light.a;\n  vec3 from = toward.xyz / light.a;\n  float facing = max(dot(n, from), 0.0) + (1.0 - min(length(from), 1.0)) * 0.25;\n  return arriving * facing;\n}\n\n/**\n * The same from a dense volume: one sample a texel, the light in the lower half of y and its\n * direction in the upper. A lookup kept inside the samples never filters across the halves.\n */\nvec3 driftLightDense(vec3 world, vec3 n, float spacing) {\n  ivec3 size = textureSize(uDriftLightAtlas, 0);\n  vec3 dims = vec3(float(size.x), float(size.y / 2), float(size.z));\n  vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / spacing;\n  if (any(lessThan(at, vec3(0.0))) || any(greaterThan(at, dims - 1.0))) return vec3(0.0);\n  vec3 uvw = (at + 0.5) / vec3(dims.x, dims.y * 2.0, dims.z);\n  vec4 light = textureLod(uDriftLightAtlas, uvw, 0.0);\n  if (light.a < 1e-3) return vec3(0.0);\n  vec4 toward = textureLod(uDriftLightAtlas, uvw + vec3(0.0, 0.5, 0.0), 0.0);\n  return driftLightFacing(light, toward, n);\n}\n\n/** The summed light arriving on a surface at `world` facing `n`. A negative spacing is dense. */\nvec3 driftLightIrradiance(vec3 world, vec3 n) {\n  float spacing = uDriftLightOrigin.w;\n  if (spacing < 0.0) return driftLightDense(world, n, -spacing);\n  vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / (3.0 * spacing);\n  ivec3 cell = ivec3(floor(at));\n  if (any(lessThan(cell, ivec3(0))) || any(greaterThanEqual(cell, textureSize(uDriftLightIndex, 0)))) {\n    return vec3(0.0);\n  }\n  uint id = texelFetch(uDriftLightIndex, cell, 0).r;\n  if (id == 0u) return vec3(0.0);\n  /* A brick is eight texels across (its light block, then its direction block) and four up and deep. */\n  ivec3 size = textureSize(uDriftLightAtlas, 0);\n  int brick = int(id) - 1;\n  int across = size.x / 8;\n  int down = size.y / 4;\n  vec3 corner = vec3(\n    float((brick % across) * 8),\n    float(((brick / across) % down) * 4),\n    float((brick / (across * down)) * 4)\n  );\n  vec3 texel = 1.0 / vec3(size);\n  vec3 inside = (at - vec3(cell)) * 3.0 + 0.5;\n  vec4 light = textureLod(uDriftLightAtlas, (corner + inside) * texel, 0.0);\n  if (light.a < 1e-3) return vec3(0.0);\n  vec4 toward = textureLod(uDriftLightAtlas, (corner + vec3(4.0, 0.0, 0.0) + inside) * texel, 0.0);\n  return driftLightFacing(light, toward, n);\n}\n";

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

@@ -29,7 +29,7 @@
 export const DRIFT_LIGHT_GLSL = /* glsl */ `
 /** x how much of the summed light is in the frame (0 off), y the radius, z the band, w the scale. */
 uniform vec4 uDriftLight;
-/** xyz the first brick's first sample; w metres between samples, a third of a brick. */
+/** xyz the first sample; w metres between samples — a third of a brick, or negated for a dense volume. */
 uniform vec4 uDriftLightOrigin;
 uniform highp usampler3D uDriftLightIndex;  // wgsl:share shadow
 uniform highp sampler3D uDriftLightAtlas;
@@ -41,9 +41,38 @@ float driftLightShare(vec3 world) {
   return smoothstep(uDriftLight.y - uDriftLight.z, uDriftLight.y, away) * uDriftLight.x;
 }
 
-/** The summed light arriving on a surface at \`world\` facing \`n\`. */
+/**
+ * A sample's light and direction turned into the light on a surface facing \`n\`: Lambert for a
+ * single light, a quarter for light arriving from everywhere (see \`bake.ts\`). One statement for
+ * both kinds of volume.
+ */
+vec3 driftLightFacing(vec4 light, vec4 toward, vec3 n) {
+  vec3 arriving = light.rgb / light.a;
+  vec3 from = toward.xyz / light.a;
+  float facing = max(dot(n, from), 0.0) + (1.0 - min(length(from), 1.0)) * 0.25;
+  return arriving * facing;
+}
+
+/**
+ * The same from a dense volume: one sample a texel, the light in the lower half of y and its
+ * direction in the upper. A lookup kept inside the samples never filters across the halves.
+ */
+vec3 driftLightDense(vec3 world, vec3 n, float spacing) {
+  ivec3 size = textureSize(uDriftLightAtlas, 0);
+  vec3 dims = vec3(float(size.x), float(size.y / 2), float(size.z));
+  vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / spacing;
+  if (any(lessThan(at, vec3(0.0))) || any(greaterThan(at, dims - 1.0))) return vec3(0.0);
+  vec3 uvw = (at + 0.5) / vec3(dims.x, dims.y * 2.0, dims.z);
+  vec4 light = textureLod(uDriftLightAtlas, uvw, 0.0);
+  if (light.a < 1e-3) return vec3(0.0);
+  vec4 toward = textureLod(uDriftLightAtlas, uvw + vec3(0.0, 0.5, 0.0), 0.0);
+  return driftLightFacing(light, toward, n);
+}
+
+/** The summed light arriving on a surface at \`world\` facing \`n\`. A negative spacing is dense. */
 vec3 driftLightIrradiance(vec3 world, vec3 n) {
   float spacing = uDriftLightOrigin.w;
+  if (spacing < 0.0) return driftLightDense(world, n, -spacing);
   vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / (3.0 * spacing);
   ivec3 cell = ivec3(floor(at));
   if (any(lessThan(cell, ivec3(0))) || any(greaterThanEqual(cell, textureSize(uDriftLightIndex, 0)))) {
@@ -66,10 +95,6 @@ vec3 driftLightIrradiance(vec3 world, vec3 n) {
   vec4 light = textureLod(uDriftLightAtlas, (corner + inside) * texel, 0.0);
   if (light.a < 1e-3) return vec3(0.0);
   vec4 toward = textureLod(uDriftLightAtlas, (corner + vec3(4.0, 0.0, 0.0) + inside) * texel, 0.0);
-  vec3 arriving = light.rgb / light.a;
-  vec3 from = toward.xyz / light.a;
-  /* Lambert for a single light, a quarter for light arriving from everywhere: see \`bake.ts\`. */
-  float facing = max(dot(n, from), 0.0) + (1.0 - min(length(from), 1.0)) * 0.25;
-  return arriving * facing;
+  return driftLightFacing(light, toward, n);
 }
 `;

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

@@ -13,6 +13,7 @@ import { SKINNING_GLSL } from '../skinning.js';
 import { SURFACE_GLSL } from './surface.js';
 import { MAIN_GLSL } from './main.js';
 import { DRIFT_LIGHT_GLSL } from './driftLight.js';
+import { SURFACE_EFFECTS_GLSL } from './surfaceEffects.js';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from '../vertexChannel.js';
 import { FULL_LIGHT_BUDGET } from '../../uniformVectorBudget.js';
 /**
@@ -27,7 +28,7 @@ layout(location = 1) in vec3 aNormal;
 layout(location = 2) in vec3 aColor;
 layout(location = 3) in float aEmissive;
 layout(location = 4) in float aSpecular;
-layout(location = 5) in vec2 aUv;
+layout(location = 5) in vec3 aUv;
 layout(location = 6) in vec3 aEmissiveColor;
 layout(location = 7) in float aRoughness;
 layout(location = 8) in float aGrain;
@@ -145,7 +146,7 @@ out vec3 vWorldPos;
 out float vEmissive;
 out float vSpecular;
 out vec4 vLightPos;
-out vec2 vUv;
+out vec3 vUv;
 out vec3 vEmissiveColor;
 out float vRoughness;
 out float vGrain;
@@ -242,7 +243,7 @@ void main() {
   vColor = aColor * tint;
   vEmissive = aEmissive;
   vSpecular = aSpecular;
-  vUv = aUv * uUvScale;
+  vUv = vec3(aUv.xy * uUvScale, aUv.z);
   vEmissiveColor = aEmissiveColor;
   vRoughness = aRoughness;
   vGrain = aGrain;
@@ -386,6 +387,7 @@ export function flatFrag(options) {
         /* Unconditional for the same reason, and called only where a cutoff was asked for. */
         CUTOUT_COVERAGE_GLSL,
         DRIFT_LIGHT_GLSL,
+        SURFACE_EFFECTS_GLSL,
         MAIN_GLSL,
     ].join('\n'), {
         POINT_SHADOWS: options.pointShadows,