@driftengine/core 4.5.0 → 4.6.0

package/src/render/rainField.ts

@@ -53,6 +53,17 @@ export interface RainFieldOptions {
   streakSec?: number;
   /** The ground drops land on, and the roofs they do not fall through. */
   ground?: GroundSurface;
+  /**
+   * How near the viewer a streak may pass and still be drawn, metres. Default 1.
+   *
+   * **A drop that close is out of any focus a camera holds**, and drawn sharp it was a bar across
+   * the frame: a streak is a world-space width, so a 6 mm drop 30 cm from the eye drew fourteen
+   * pixels thick and as long as the frame, from a city seen from the air in the rain. A streak
+   * whose nearest point is inside this distance is not drawn; the drop keeps falling, as a
+   * sheltered one does. What it gives up is rain on a lens or a visor, which this field never
+   * drew as such anyway. What would make it wrong is a view that wants drops in macro: pass 0.
+   */
+  clearM?: number;
 }
 
 export class RainField {
@@ -97,6 +108,8 @@ export class RainField {
    */
   streakSec: number;
   private readonly ground: GroundSurface | null;
+  /** How near the viewer a streak may pass and still be drawn, squared. */
+  private readonly clear2: number;
   /** Drops not drawn this update because something was over them. */
   private sheltered = 0;
   /**
@@ -125,6 +138,8 @@ export class RainField {
     this.speedMps = options.speedMps ?? 9;
     this.streakSec = options.streakSec ?? 0.04;
     this.ground = options.ground ?? null;
+    const clear = options.clearM ?? 1;
+    this.clear2 = clear * clear;
     this.segments = createLineSegments(options.count);
     this.x = new Float32Array(options.count);
     this.y = new Float32Array(options.count);
@@ -212,15 +227,34 @@ export class RainField {
         continue;
       }
 
+      /* Where it was a shutter-time ago, which is the streak: down by its fall and back along the
+         wind, so a gust leans every drop at the same angle without anything trigonometric. */
+      const backX = -windX * this.streakSec;
+      const backY = this.speedMps * this.streakSec;
+      const backZ = -windZ * this.streakSec;
+      /* Too near the eye to be drawn (`clearM`): the streak's nearest point to the viewer. */
+      if (this.clear2 > 0) {
+        const ox = dropX - viewerX;
+        const oy = dropY - viewerY;
+        const oz = dropZ - viewerZ;
+        const length2 = backX * backX + backY * backY + backZ * backZ;
+        const along =
+          length2 > 0
+            ? Math.min(Math.max(-(ox * backX + oy * backY + oz * backZ) / length2, 0), 1)
+            : 0;
+        const nx = ox + backX * along;
+        const ny = oy + backY * along;
+        const nz = oz + backZ * along;
+        if (nx * nx + ny * ny + nz * nz < this.clear2) continue;
+      }
+
       const at = this.segments.count;
       this.segments.from[at * 3] = dropX;
       this.segments.from[at * 3 + 1] = dropY;
       this.segments.from[at * 3 + 2] = dropZ;
-      /* Where it was a shutter-time ago, which is the streak: down by its fall and back along the
-         wind, so a gust leans every drop at the same angle without anything trigonometric. */
-      this.segments.to[at * 3] = dropX - windX * this.streakSec;
-      this.segments.to[at * 3 + 1] = dropY + this.speedMps * this.streakSec;
-      this.segments.to[at * 3 + 2] = dropZ - windZ * this.streakSec;
+      this.segments.to[at * 3] = dropX + backX;
+      this.segments.to[at * 3 + 1] = dropY + backY;
+      this.segments.to[at * 3 + 2] = dropZ + backZ;
       this.segments.count = at + 1;
     }
     this.primed = true;

package/src/render/recon/lateDepth.ts

@@ -0,0 +1,83 @@
+/**
+ * The depth a reconstructing frame's late draws are tested against at an output pixel, taken from
+ * the render's jittered depth. `shaders/recon/lateDepth.wgsl.ts` is the same arithmetic on the device.
+ *
+ * **Each surface taken to the pixel, and the nearest of them.** A late draw — a glow, a pane, a
+ * caption — is drawn unjittered at the output size, and it has to meet the depth of what it lies on
+ * where *it* is. Each of the four render texels about the pixel, placed where the jitter put it,
+ * carries its surface on to the pixel's unjittered centre along that surface's own slope; the
+ * nearest of the four so carried stands, and a quarter of its slope is given back toward the far
+ * side so that a draw lying exactly on the surface is not decided by rounding. On a plane all four
+ * arrive at the plane's own depth at the pixel: exact, and the same whatever the jitter was.
+ *
+ * **A texel's slope is the smaller of its two differences along each axis, and none where they
+ * disagree in sign** — the minmod limiter. Beside an edge one difference is the jump, so it is the
+ * other, the surface's own, that is taken; a sliver one texel wide disagrees both ways and keeps its
+ * own depth, the nearest of the four as before. So a translucent draw still never comes through an
+ * opaque edge the render covered by more than the render's own texel.
+ *
+ * **Why this replaced the nearest of the four.** On a wall seen aslant the nearest of four neighbours
+ * stands up to a texel's step in front of the wall at the pixel, so a glow lying a few centimetres
+ * proud of it was judged behind the wall; and which neighbour was nearest moved with the jitter, so
+ * the glow was drawn one frame and not the next. Measured on a street of lit facades: every strip of
+ * glow on every tower flickered frame by frame, 12,415 pixels of one tower between two frames.
+ *
+ * What it gives up: a surface curving within a texel is carried on as a plane, which a quarter-step
+ * tolerance covers. What would make it wrong is depth that is not affine on a plane — a depth written
+ * from the fragment stage — which nothing drawn before the late pass writes.
+ */
+import { REVERSED_DEPTH } from '../depthConvention.ts';
+
+/** The share of a surface's slope given back toward the far side, for a draw lying on it. */
+const TOLERANCE_SHARE = 0.25;
+
+/** The smaller of two differences, or none where they disagree in sign. */
+function minmod(a: number, b: number): number {
+  if (a * b <= 0) return 0;
+  return Math.abs(a) < Math.abs(b) ? a : b;
+}
+
+/**
+ * Where output pixel (`outX`, `outY`) — its centre, in pixels — falls among the render texels
+ * jittered by (`jitterX`, `jitterY`) render texels: into `out`, the cell's first texel and the
+ * fraction across it, `[x, y, fx, fy]`.
+ */
+export function lateDepthCell(
+  outX: number,
+  outY: number,
+  renderWidth: number,
+  renderHeight: number,
+  outputWidth: number,
+  outputHeight: number,
+  jitterX: number,
+  jitterY: number,
+  out: Float64Array | Float32Array,
+): void {
+  /* A texel stands at its index plus a half less the jitter, as the resolve places it. */
+  const x = (outX * renderWidth) / outputWidth - 0.5 + jitterX;
+  const y = (outY * renderHeight) / outputHeight - 0.5 + jitterY;
+  out[0] = Math.floor(x);
+  out[1] = Math.floor(y);
+  out[2] = x - Math.floor(x);
+  out[3] = y - Math.floor(y);
+}
+
+/**
+ * The depth to test against, from `taps` — a 4x4 block of render texels, row-major, starting one
+ * texel up and left of the cell's first — at (`fx`, `fy`) across the cell.
+ */
+export function lateDepthAt(taps: ArrayLike<number>, fx: number, fy: number): number {
+  const t = (x: number, y: number): number => taps[(y + 1) * 4 + x + 1] as number;
+  let depth = REVERSED_DEPTH ? -Infinity : Infinity;
+  for (let oy = 0; oy < 2; oy += 1) {
+    for (let ox = 0; ox < 2; ox += 1) {
+      const d = t(ox, oy);
+      const gx = minmod(t(ox + 1, oy) - d, d - t(ox - 1, oy));
+      const gy = minmod(t(ox, oy + 1) - d, d - t(ox, oy - 1));
+      const carried = d + gx * (fx - ox) + gy * (fy - oy);
+      const give = TOLERANCE_SHARE * Math.max(Math.abs(gx), Math.abs(gy));
+      depth = REVERSED_DEPTH ? Math.max(depth, carried - give) : Math.min(depth, carried + give);
+    }
+  }
+  return depth;
+}

package/src/render/recon/resolve.ts

@@ -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.
@@ -44,6 +67,16 @@ import {
 } from './disocclusion.ts';
 import type { DisocclusionParams } from './disocclusion.ts';
 import { sampleBilinear, sampleHistoryBicubic5 } from './reproject.ts';
+import {
+  TEMPORAL_FLICKER,
+  flickerBlend,
+  flickerRule,
+  flickerWidening,
+  freshFlicker,
+  nextFlicker,
+  stillness,
+} from '../temporalAa.ts';
+import type { Flicker, FlickerRule } from '../temporalAa.ts';
 
 /** What a reconstruction is asked for. */
 export interface ReconQuality {
@@ -140,6 +173,12 @@ export interface ResolveFrame {
   readonly inverseViewProj: ArrayLike<number>;
   /** Last frame's view-projection and its inverse, unjittered. */
   readonly previousViewProj: ArrayLike<number>;
+  /**
+   * Last frame's view-projection times this frame's inverse: where a texel's clip position was
+   * last frame. Derived from the two when absent; a caller holding its matrices at a lower precision
+   * than it multiplies at passes its own product, as the renderer does.
+   */
+  readonly reprojection?: ArrayLike<number>;
   readonly previousInverseViewProj: ArrayLike<number>;
   readonly eye: ArrayLike<number>;
   readonly previousEye: ArrayLike<number>;
@@ -148,6 +187,22 @@ export interface ResolveFrame {
   readonly previousJitter: ArrayLike<number>;
   readonly quality: ReconQuality;
   readonly disocclusion: DisocclusionParams;
+  /**
+   * Last frame's flicker records, output size, four floats a pixel — the spread, this period's
+   * running sum, the last period's mean, and how many periods running repeated, as `Flicker` holds
+   * them — or absent for the resolve without its anti-flicker.
+   */
+  readonly flicker?: ArrayLike<number> | null;
+  /**
+   * Last frame's depth swings, output size, one float a pixel: the largest miss, relative to the
+   * depth, of last frame's depth against the one this pixel's surface should have had, seen lately
+   * — held, and halving over a period. Carried with `flicker` and read only with it.
+   */
+  readonly depthSwing?: ArrayLike<number> | null;
+  /** Whether this frame samples the first phase of the jitter's period. */
+  readonly periodStart?: boolean;
+  /** The jitter's period: the reconstruction's own phase count, not the temporal resolve's. */
+  readonly flickerPhases?: number;
 }
 
 /**
@@ -170,6 +225,13 @@ export function reconstructionWeight(dx: number, dy: number): number {
  */
 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);
@@ -185,6 +247,36 @@ 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: ResolveFrame | null = null;
+
+/** `frame.reprojection`, or the product of its two matrices, multiplied once per frame. */
+function reprojectionOf(frame: ResolveFrame): ArrayLike<number> {
+  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] as number) * (b[c * 4 + k] as number);
+        REPROJECTION[c * 4 + r] = sum;
+      }
+    }
+  }
+  return REPROJECTION;
+}
+const HELD: Flicker = { spread: 0, sum: 0, mean: 0, repeated: 0 };
+const CARRIED: Flicker = { 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: FlickerRule = TEMPORAL_FLICKER;
 
 function clampTexel(value: number, size: number): number {
   return value < 0 ? 0 : value >= size ? size - 1 : value;
@@ -296,7 +388,15 @@ function normalAt(
  * 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: ResolveFrame, u: number, v: number, dx: number, dy: number): number {
+function historyWeight(
+  frame: ResolveFrame,
+  u: number,
+  v: number,
+  dx: number,
+  dy: number,
+  swing: number,
+): number {
+  missed = -1;
   if (!frame.hasHistory) return 0;
   const rw = frame.renderWidth;
   const rh = frame.renderHeight;
@@ -309,28 +409,46 @@ function historyWeight(frame: ResolveFrame, u: number, v: number, dx: number, dy
     mv = frame.motion[flagAt + 1] as number;
     expected = frame.motion[flagAt + 2] as number;
   } else {
-    if (worldAt(frame.depth, frame.inverseViewProj, frame.jitter, rw, rh, dx, dy, WORLD) <= 0) {
-      return 0;
-    }
-    const m = frame.previousViewProj;
+    /*
+     * **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] as number)) / rw;
+    const dv = (dy + 0.5 - (frame.jitter[1] as number)) / rh;
+    const x = du * 2 - 1;
+    const y = dv * 2 - 1;
+    const z = frame.depth[dy * rw + dx] as number;
+    const inverse = frame.inverseViewProj;
+    /* The homogeneous w of the world position: none, or behind the eye, is no surface. */
+    const hw =
+      (inverse[3] as number) * x +
+      (inverse[7] as number) * y +
+      (inverse[11] as number) * z +
+      (inverse[15] as number);
+    if (!(hw > 1e-12)) return 0;
+    const m = reprojectionOf(frame);
     for (let r = 0; r < 4; r += 1) {
       CLIP[r] =
-        (m[r] as number) * (WORLD[0] as number) +
-        (m[4 + r] as number) * (WORLD[1] as number) +
-        (m[8 + r] as number) * (WORLD[2] as number) +
+        (m[r] as number) * x +
+        (m[4 + r] as number) * y +
+        (m[8 + r] as number) * z +
         (m[12 + r] as number);
     }
     /*
      * 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] as number;
-    const du = (dx + 0.5 - (frame.jitter[0] as number)) / rw;
-    const dv = (dy + 0.5 - (frame.jitter[1] as number)) / rh;
-    mu = ((CLIP[0] as number) / expected) * 0.5 + 0.5 - du;
-    mv = ((CLIP[1] as number) / expected) * 0.5 + 0.5 - dv;
+    expected = (CLIP[3] as number) / hw;
+    mu = ((CLIP[0] as number) / (CLIP[3] as number)) * 0.5 + 0.5 - du;
+    mv = ((CLIP[1] as number) / (CLIP[3] as number)) * 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)) return 0;
@@ -440,22 +558,32 @@ function historyWeight(frame: ResolveFrame, u: number, v: number, dx: number, dy
       (NORMAL[2] as number) * (PREVIOUS_NORMAL[2] as number);
     normalDot = 1 - planar * (1 - cosine);
   }
+  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,
+    slope + swung,
   );
   return (HISTORY[3] as number) * 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: ResolveFrame, ox: number, oy: number, out: Float32Array): void {
+export function resolvePixel(
+  frame: ResolveFrame,
+  ox: number,
+  oy: number,
+  out: Float32Array,
+  record?: Float32Array,
+  swingOut?: Float32Array,
+): void {
   const rw = frame.renderWidth;
   const rh = frame.renderHeight;
   const ow = frame.outputWidth;
@@ -508,8 +636,58 @@ export function resolvePixel(frame: ResolveFrame, ox: number, oy: number, out: F
   for (let c = 0; c < 3; c += 1) GATHERED[c] = (GATHERED[c] as number) / 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] as number) : 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] as number) * 0.2126 +
+      (GATHERED[1] as number) * 0.7152 +
+      (GATHERED[2] as number) * 0.0722;
+    const at = (oy * ow + ox) * 4;
+    if (weight > 0) {
+      HELD.spread = records[at] as number;
+      HELD.sum = records[at + 1] as number;
+      HELD.mean = records[at + 2] as number;
+      HELD.repeated = records[at + 3] as number;
+    } 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] as number) - widen;
+      HIGH[c] = (HIGH[c] as number) + 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;
@@ -529,6 +707,8 @@ export function resolvePixel(frame: ResolveFrame, ox: number, oy: number, out: F
 }
 
 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);
@@ -541,19 +721,25 @@ const OFFSETS: readonly (readonly [number, number])[] = [
 
 /**
  * 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: ResolveFrame,
   history: Float32Array,
   shown: Float32Array,
+  records?: Float32Array,
+  swings?: Float32Array,
 ): void {
   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] as number;
     }
   }
   for (let y = 0; y < oh; y += 1) {

package/src/render/rendererHarness.ts

@@ -72,6 +72,10 @@ export function recordingGl(
   const programFragments = new WeakMap<object, string>();
   const calls: { name: string; args: unknown[] }[] = [];
   const constants: Record<string, number> = {
+    /* 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/src/render/sceneTarget.ts

@@ -755,6 +755,8 @@ export 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;
@@ -1023,6 +1025,8 @@ export class SceneTarget {
       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

package/src/render/shaders/depth.ts

@@ -64,14 +64,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
@@ -103,7 +104,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
@@ -196,16 +197,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;
@@ -289,19 +291,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/src/render/shaders/flat/driftLight.ts

@@ -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);
 }
 `;