@driftengine/core 4.4.2 → 4.6.0

package/src/render/shaders/recon/lateDepth.wgsl.ts

@@ -0,0 +1,72 @@
+/**
+ * The render's depth, taken up to the output size for the draws that land after the upscale.
+ *
+ * `recon/lateDepth.ts` is the same arithmetic and says why: **each of the four render texels about
+ * the pixel carries its surface on to the pixel's unjittered centre** along a slope the minmod
+ * limiter takes — the smaller of its two differences on an axis, none where they disagree — and the
+ * nearest of the four so carried stands, less a quarter of its slope. On a plane that is the plane's
+ * own depth at the pixel whatever the jitter; at an edge no slope crosses the jump, so a
+ * translucent draw is never let through an opaque edge the render covered.
+ *
+ * Hand-written, and built by concatenation rather than a template literal: the reconstruction's
+ * passes have no WebGL2 twin (the AGENTS.md exception for them), and a `${}` inside WGSL source is
+ * the thing that rule forbids.
+ */
+import { REVERSED_DEPTH } from '../../depthConvention.ts';
+
+/** The nearer of two stored depths: the larger in a reversed buffer. */
+const NEARER = REVERSED_DEPTH ? 'max' : 'min';
+/** Toward the far side: down in a reversed buffer. */
+const FARWARD = REVERSED_DEPTH ? '-' : '+';
+/** Where the search for the nearest starts: the far plane. */
+const FARTHEST = REVERSED_DEPTH ? '0.0' : '1.0';
+
+export const LATE_DEPTH_WGSL =
+  '@group(0) @binding(0) var source: texture_depth_2d;\n' +
+  '/* The render size and the output size; then the frame jitter, in render texels. */\n' +
+  '@group(0) @binding(1) var<uniform> sizes: array<vec4<f32>, 2>;\n' +
+  '\n' +
+  '@vertex\n' +
+  'fn lateDepthVert(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {\n' +
+  '  let x = f32((index << 1u) & 2u);\n' +
+  '  let y = f32(index & 2u);\n' +
+  '  return vec4<f32>(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);\n' +
+  '}\n' +
+  '\n' +
+  'fn tap(base: vec2<i32>, x: i32, y: i32) -> f32 {\n' +
+  '  let top = vec2<i32>(sizes[0].xy) - vec2<i32>(1);\n' +
+  '  return textureLoad(source, clamp(base + vec2<i32>(x, y), vec2<i32>(0), top), 0);\n' +
+  '}\n' +
+  '\n' +
+  '/* The smaller of two differences, or none where they disagree in sign. */\n' +
+  'fn minmod(a: f32, b: f32) -> f32 {\n' +
+  '  if (a * b <= 0.0) {\n' +
+  '    return 0.0;\n' +
+  '  }\n' +
+  '  return select(b, a, abs(a) < abs(b));\n' +
+  '}\n' +
+  '\n' +
+  '@fragment\n' +
+  'fn lateDepthFrag(@builtin(position) at: vec4<f32>) -> @builtin(frag_depth) f32 {\n' +
+  '  /* A texel stands at its index plus a half less the jitter, as the resolve places it. */\n' +
+  '  let centre = at.xy * sizes[0].xy / sizes[0].zw - vec2<f32>(0.5) + sizes[1].xy;\n' +
+  '  let base = vec2<i32>(floor(centre));\n' +
+  '  let f = centre - floor(centre);\n' +
+  '  var depth = ' +
+  FARTHEST +
+  ';\n' +
+  '  for (var oy = 0; oy < 2; oy += 1) {\n' +
+  '    for (var ox = 0; ox < 2; ox += 1) {\n' +
+  '      let d = tap(base, ox, oy);\n' +
+  '      let gx = minmod(tap(base, ox + 1, oy) - d, d - tap(base, ox - 1, oy));\n' +
+  '      let gy = minmod(tap(base, ox, oy + 1) - d, d - tap(base, ox, oy - 1));\n' +
+  '      let carried = d + gx * (f.x - f32(ox)) + gy * (f.y - f32(oy));\n' +
+  '      depth = ' +
+  NEARER +
+  '(depth, carried ' +
+  FARWARD +
+  ' 0.25 * max(abs(gx), abs(gy)));\n' +
+  '    }\n' +
+  '  }\n' +
+  '  return clamp(depth, 0.0, 1.0);\n' +
+  '}\n';

package/src/render/shaders/recon/motion.wgsl.ts

@@ -88,6 +88,90 @@ fn motionUv(clip: vec4<f32>) -> vec2<f32> {
   return clip.xy / clip.w * 0.5 + vec2<f32>(0.5);
 }
 
+/*
+ * The skinned stage: the joints this frame and last frame, read from two palette textures of the
+ * frame's ring. The same four weighted products in the same order as the scene's own skinning, so
+ * the depth this stage produces is the depth the scene wrote.
+ */
+@group(1) @binding(0) var palette: texture_2d<f32>;
+@group(1) @binding(1) var previousPalette: texture_2d<f32>;
+
+fn jointOf(source: texture_2d<f32>, index: i32) -> mat4x4<f32> {
+  let x = index * 4;
+  return mat4x4<f32>(
+    textureLoad(source, vec2<i32>(x, 0), 0),
+    textureLoad(source, vec2<i32>(x + 1, 0), 0),
+    textureLoad(source, vec2<i32>(x + 2, 0), 0),
+    textureLoad(source, vec2<i32>(x + 3, 0), 0));
+}
+
+fn skinOf(source: texture_2d<f32>, joints: vec4<f32>, weights: vec4<f32>) -> mat4x4<f32> {
+  return jointOf(source, i32(joints.x)) * weights.x
+       + jointOf(source, i32(joints.y)) * weights.y
+       + jointOf(source, i32(joints.z)) * weights.z
+       + jointOf(source, i32(joints.w)) * weights.w;
+}
+
+@vertex
+fn motionSkinnedVert(
+  @location(0) position: vec3<f32>,
+  @location(11) joints: vec4<f32>,
+  @location(12) weights: vec4<f32>,
+) -> Varyings {
+  let world = draw.model * (skinOf(palette, joints, weights) * vec4<f32>(position, 1.0));
+  let wasWorld =
+    draw.previousModel * (skinOf(previousPalette, joints, weights) * vec4<f32>(position, 1.0));
+  var out: Varyings;
+  out.clip = frame.raster * world;
+  out.now = frame.viewProj * world;
+  out.was = frame.previousViewProj * wasWorld;
+  return out;
+}
+
+/*
+ * The rewritten stage: a mesh whose vertices were rewritten this frame reads last frame's rows from
+ * a second buffer of the same stride, so each vertex carries both of its positions.
+ */
+@vertex
+fn motionDynamicVert(
+  @location(0) position: vec3<f32>,
+  @location(1) previousPosition: vec3<f32>,
+) -> Varyings {
+  let world = draw.model * vec4<f32>(position, 1.0);
+  let wasWorld = draw.previousModel * vec4<f32>(previousPosition, 1.0);
+  var out: Varyings;
+  out.clip = frame.raster * world;
+  out.now = frame.viewProj * world;
+  out.was = frame.previousViewProj * wasWorld;
+  return out;
+}
+
+/*
+ * The instanced stage: each instance's matrix this frame and last frame, read from the batch's
+ * placement and the copy of last frame's it kept. Slot for slot, so an instance is paired with
+ * itself; the per-draw matrices are not read.
+ */
+@vertex
+fn motionInstancedVert(
+  @location(0) position: vec3<f32>,
+  @location(2) m0: vec4<f32>,
+  @location(3) m1: vec4<f32>,
+  @location(4) m2: vec4<f32>,
+  @location(5) m3: vec4<f32>,
+  @location(6) p0: vec4<f32>,
+  @location(7) p1: vec4<f32>,
+  @location(8) p2: vec4<f32>,
+  @location(9) p3: vec4<f32>,
+) -> Varyings {
+  let world = mat4x4<f32>(m0, m1, m2, m3) * vec4<f32>(position, 1.0);
+  let wasWorld = mat4x4<f32>(p0, p1, p2, p3) * vec4<f32>(position, 1.0);
+  var out: Varyings;
+  out.clip = frame.raster * world;
+  out.now = frame.viewProj * world;
+  out.was = frame.previousViewProj * wasWorld;
+  return out;
+}
+
 @fragment
 fn motionFrag(in: Varyings) -> @location(0) vec4<f32> {
   /*

package/src/render/shaders/recon/resolve.wgsl.ts

@@ -34,12 +34,16 @@
  * fn reconMotion(x: i32, y: i32) -> vec4<f32>         // uv, previous view depth, flag
  * fn reconHistory(x: i32, y: i32) -> vec4<f32>        // output size, colour and gathered weight
  * fn reconHistoryBilinear(p: vec2<f32>) -> vec4<f32>
+ * fn reconFlicker(x: i32, y: i32) -> vec4<f32>        // output size, last frame's flicker record
+ * fn reconSwing(x: i32, y: i32) -> f32                // output size, last frame's held depth swing
  * ```
  *
  * and the uniform `recon: ReconParams`, whose struct this module declares.
  */
 import { wgslSceneDepthToNdc } from '../../depthConvention.ts';
 import { PLANAR_FROM, PLANAR_TO } from '../../recon/disocclusion.ts';
+import { DEPTH_SWING_WIDTH } from '../../recon/resolve.ts';
+import { FLICKER_BLEND, FLICKER_REPEAT, STILL_FROM, STILL_TO } from '../../temporalAa.ts';
 
 /**
  * The parameters one resolve reads, as `ResolveFrame` minus its images.
@@ -66,11 +70,16 @@ struct ReconParams {
   motionScale: f32,
   normalFloor: f32,
   normalCeiling: f32,
+  periodStart: u32,
+  antiFlicker: u32,
+  flickerMemory: f32,
+  flickerWidth: f32,
+  reprojection: mat4x4<f32>,
 }
 `;
 
 /** Floats in `ReconParams`, which is what a caller sizes its uniform buffer by. */
-export const RECON_PARAM_FLOATS = 72;
+export const RECON_PARAM_FLOATS = 92;
 
 /** `SAMPLE_SPREAD` and `CONFIDENT_WEIGHT`, which the reference exports and this must not restate. */
 export const RECON_SAMPLE_SPREAD = 0.47;
@@ -91,8 +100,8 @@ export const RECON_WORKGROUP = 8;
 export const RECON_HISTORY_FORMAT: GPUTextureFormat = 'rgba16float';
 
 /**
- * The arithmetic, as text. Defines `reconResolvePixel(ox, oy) -> vec4<f32>` — the next history's
- * colour and the weight it has gathered — and `reconSharpenAt(ox, oy) -> vec3<f32>`, the picture
+ * The arithmetic, as text. Defines `reconResolvePixel(ox, oy) -> ReconResolved` — the next
+ * history's colour and the weight it has gathered, and the pixel's next flicker record — and `reconSharpenAt(ox, oy) -> vec3<f32>`, the picture
  * shown, which reads the history the first has already written.
  */
 export const RECON_RESOLVE_CORE_WGSL = /* wgsl */ `
@@ -100,6 +109,11 @@ const RECON_SAMPLE_SPREAD: f32 = ${RECON_SAMPLE_SPREAD};
 const RECON_CONFIDENT_WEIGHT: f32 = ${RECON_CONFIDENT_WEIGHT}.0;
 const RECON_PLANAR_FROM: f32 = ${PLANAR_FROM};
 const RECON_PLANAR_TO: f32 = ${PLANAR_TO};
+const RECON_FLICKER_BLEND: f32 = ${FLICKER_BLEND};
+const RECON_FLICKER_REPEAT: f32 = ${FLICKER_REPEAT};
+const RECON_STILL_FROM: f32 = ${STILL_FROM};
+const RECON_STILL_TO: f32 = ${STILL_TO};
+const RECON_DEPTH_SWING_WIDTH: f32 = ${DEPTH_SWING_WIDTH}.0;
 
 fn reconClampTexel(value: i32, size: i32) -> i32 {
   return clamp(value, 0, size - 1);
@@ -467,6 +481,10 @@ fn reconSurfaceAt(previous: bool, x: i32, y: i32, centre: f32) -> ReconSurface {
 struct ReconHistory {
   weight: f32,
   colour: vec4<f32>,
+  /* How far the surface moved, in output pixels; read only where the weight is not zero. */
+  moved: f32,
+  /* How far, relative, last frame's depth missed the one expected there; -1 where none was held. */
+  missed: f32,
 }
 
 /*
@@ -474,10 +492,12 @@ struct ReconHistory {
  * behind last frame's eye or off its picture, and otherwise what it gathered, scaled by whether it
  * is the same surface.
  */
-fn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32) -> ReconHistory {
+fn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32, swing: f32) -> ReconHistory {
   var out: ReconHistory;
   out.weight = 0.0;
   out.colour = vec4<f32>(0.0);
+  out.moved = 0.0;
+  out.missed = -1.0;
   if (recon.hasHistory == 0u) { return out; }
   let rw = f32(recon.renderSize.x);
   let rh = f32(recon.renderSize.y);
@@ -490,20 +510,24 @@ fn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32) -> ReconHistory {
     mv = motion.y;
     expected = motion.z;
   } else {
-    let here = reconWorldAt(false, dx, dy);
-    if (!(here.depth > 0.0)) { return out; }
-    let clip = recon.previousViewProj * vec4<f32>(here.position, 1.0);
+    /* Through the one reprojection matrix the renderer multiplied: see resolve.ts. */
+    let du = (f32(dx) + 0.5 - recon.jitter.x) / rw;
+    let dv = (f32(dy) + 0.5 - recon.jitter.y) / rh;
+    let ndc = vec4<f32>(du * 2.0 - 1.0, dv * 2.0 - 1.0, reconDepth(dx, dy), 1.0);
+    let m = recon.inverseViewProj;
+    let hw = m[0][3] * ndc.x + m[1][3] * ndc.y + m[2][3] * ndc.z + m[3][3];
+    if (!(hw > 1e-12)) { return out; }
+    let clip = recon.reprojection * ndc;
     /*
      * 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.w;
-    let du = (f32(dx) + 0.5 - recon.jitter.x) / rw;
-    let dv = (f32(dy) + 0.5 - recon.jitter.y) / rh;
-    mu = (clip.x / expected) * 0.5 + 0.5 - du;
-    mv = (clip.y / expected) * 0.5 + 0.5 - dv;
+    expected = clip.w / hw;
+    mu = (clip.x / clip.w) * 0.5 + 0.5 - du;
+    mv = (clip.y / clip.w) * 0.5 + 0.5 - dv;
   }
 
+  out.moved = length(vec2<f32>(mu * f32(recon.outputSize.x), mv * f32(recon.outputSize.y)));
   let pu = u + mu;
   let pv = v + mv;
   if (!(pu >= 0.0 && pu <= 1.0 && pv >= 0.0 && pv <= 1.0)) { return out; }
@@ -550,13 +574,41 @@ fn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32) -> ReconHistory {
       normalDot = 1.0 - planar * (1.0 - dot(hereNormal.normal, thereNormal.normal));
     }
   }
-  let trust = reconDisocclusion(expected, held, length(vec2<f32>(mu, mv)), normalDot, here.slope);
+  if (held > 0.0 && expected > 0.0) { out.missed = abs(held - expected) / expected; }
+  /* A still pixel's own held depth swing: see resolve.ts. */
+  var swung = 0.0;
+  if (swing > 0.0) {
+    swung = RECON_DEPTH_SWING_WIDTH * swing *
+      (1.0 - reconSmoothstep(RECON_STILL_FROM, RECON_STILL_TO, out.moved));
+  }
+  let trust = reconDisocclusion(
+    expected,
+    held,
+    length(vec2<f32>(mu, mv)),
+    normalDot,
+    here.slope + swung,
+  );
   out.weight = out.colour.w * trust;
   return out;
 }
 
-/* One output pixel: the history's next colour, before sharpening, and the weight it has gathered. */
-fn reconResolvePixel(ox: i32, oy: i32) -> vec4<f32> {
+/* temporalAa.ts's repeats: whether two periods' means are the same, one to zero. */
+fn reconRepeats(mean: f32, previous: f32) -> f32 {
+  let apart = abs(mean - previous) / max(max(mean, previous), 1.0 / 255.0);
+  return 1.0 - reconSmoothstep(RECON_FLICKER_REPEAT, 2.0 * RECON_FLICKER_REPEAT, apart);
+}
+
+struct ReconResolved {
+  /* The history's next colour, before sharpening, and the weight it has gathered. */
+  colour: vec4<f32>,
+  /* The pixel's next flicker record: spread, this period's sum, last period's mean, repeats. */
+  record: vec4<f32>,
+  /* And its next held depth swing. */
+  swing: f32,
+}
+
+/* One output pixel: the history's next colour and weight, and its next flicker record. */
+fn reconResolvePixel(ox: i32, oy: i32) -> ReconResolved {
   let rw = i32(recon.renderSize.x);
   let rh = i32(recon.renderSize.y);
   let ow = i32(recon.outputSize.x);
@@ -604,18 +656,68 @@ fn reconResolvePixel(ox: i32, oy: i32) -> vec4<f32> {
   accum = accum / gathered;
 
   /* The history, and the weight it still deserves; a tenth of each frame is always new. */
-  let cap = (1.0 - recon.alpha) / recon.alpha;
-  let history = reconHistoryWeight(u, v, dx, dy);
+  var swing = 0.0;
+  if (recon.antiFlicker != 0u) { swing = reconSwing(ox, oy); }
+  let history = reconHistoryWeight(u, v, dx, dy, swing);
+  var cap = (1.0 - recon.alpha) / recon.alpha;
+  var low = box.low;
+  var high = box.high;
+  var out: ReconResolved;
+  out.record = vec4<f32>(0.0);
+  out.swing = 0.0;
+  /* The anti-flicker, operation for operation resolve.ts's: see temporalAa.ts. */
+  if (recon.antiFlicker != 0u) {
+    let seen = dot(accum, vec3<f32>(0.2126, 0.7152, 0.0722));
+    let memory = recon.flickerMemory;
+    let width = recon.flickerWidth;
+    var held = vec4<f32>(0.0, seen * memory, seen, 0.0);
+    if (history.weight > 0.0) { held = reconFlicker(ox, oy); }
+    var still = 0.0;
+    if (history.weight > 0.0) {
+      still = 1.0 - reconSmoothstep(RECON_STILL_FROM, RECON_STILL_TO, history.moved);
+    }
+    let apart = abs(seen - held.z);
+    let within = apart <= width * held.x + 1.0 / 255.0;
+    let proven = held.w > 0.75 && within;
+    var widen = 0.0;
+    let base = 1.0 - recon.alpha;
+    var keep = base;
+    if (proven) {
+      widen = width * held.x * still;
+      keep = base + (RECON_FLICKER_BLEND - base) * still;
+    }
+    low = low - vec3<f32>(widen);
+    high = high + vec3<f32>(widen);
+    cap = keep / (1.0 - keep);
+    var sum = held.y;
+    var mean = held.z;
+    var repeated = 0.0;
+    if (within) { repeated = held.w; }
+    if (recon.periodStart != 0u) {
+      if (reconRepeats(sum, mean) > 0.5) { repeated = min(1.0, repeated + 0.5); } else { repeated = 0.0; }
+      mean = sum;
+      sum = 0.0;
+    }
+    out.record = vec4<f32>(
+      held.x + (apart - held.x) * memory,
+      sum + seen * memory,
+      mean,
+      repeated * still,
+    );
+    /* The peak carried on, halving over a period, whatever the test said. */
+    if (history.missed >= 0.0) { out.swing = max(history.missed, swing * pow(0.5, memory)); }
+  }
   let kept = min(cap, history.weight);
 
   let total = kept + gathered;
   var mixed = accum;
   if (kept > 0.0) {
-    let clipped = reconClipToBox(reconToYCoCg(history.colour.xyz), box.low, box.high);
+    let clipped = reconClipToBox(reconToYCoCg(history.colour.xyz), low, high);
     mixed = reconAccumulate(accum, reconFromYCoCg(clipped), 1.0, gathered / total);
   }
   let known = min(1.0, total / RECON_CONFIDENT_WEIGHT);
-  return vec4<f32>(sample * (1.0 - known) + mixed * known, total);
+  out.colour = vec4<f32>(sample * (1.0 - known) + mixed * known, total);
+  return out;
 }
 
 /*
@@ -655,8 +757,9 @@ fn reconSharpenAt(ox: i32, oy: i32) -> vec3<f32> {
  * doing its own bilinear so the comparison is arithmetic rather than a tolerance on the device's
  * sampler.
  *
- * Two entry points over one set of bindings. `resolveMain` writes four floats a pixel — the next
- * history — and `sharpenMain` reads that history back at binding 4 and writes three.
+ * Two entry points over one set of bindings. `resolveMain` writes nine floats a pixel — the next
+ * history, the next flicker record and the next depth swing — and `sharpenMain` reads that history back at binding 4
+ * and writes three.
  */
 export function reconResolveParityWgsl(): string {
   return /* wgsl */ `
@@ -668,6 +771,16 @@ export function reconResolveParityWgsl(): string {
 ${RECON_PARAMS_WGSL}
 @group(0) @binding(5) var<uniform> recon: ReconParams;
 @group(0) @binding(6) var<storage, read_write> output: array<f32>;
+@group(0) @binding(7) var flickerTexture: texture_2d<f32>;
+@group(0) @binding(8) var swingTexture: texture_2d<f32>;
+
+fn reconFlicker(x: i32, y: i32) -> vec4<f32> {
+  return textureLoad(flickerTexture, vec2<i32>(x, y), 0);
+}
+
+fn reconSwing(x: i32, y: i32) -> f32 {
+  return textureLoad(swingTexture, vec2<i32>(x, y), 0).x;
+}
 
 fn reconScene(x: i32, y: i32) -> vec3<f32> {
   return textureLoad(sceneTexture, vec2<i32>(x, y), 0).xyz;
@@ -725,11 +838,16 @@ ${RECON_RESOLVE_CORE_WGSL}
 fn resolveMain(@builtin(global_invocation_id) id: vec3<u32>) {
   if (id.x >= recon.outputSize.x || id.y >= recon.outputSize.y) { return; }
   let value = reconResolvePixel(i32(id.x), i32(id.y));
-  let at = (id.y * recon.outputSize.x + id.x) * 4u;
-  output[at] = value.x;
-  output[at + 1u] = value.y;
-  output[at + 2u] = value.z;
-  output[at + 3u] = value.w;
+  let at = (id.y * recon.outputSize.x + id.x) * 9u;
+  output[at] = value.colour.x;
+  output[at + 1u] = value.colour.y;
+  output[at + 2u] = value.colour.z;
+  output[at + 3u] = value.colour.w;
+  output[at + 4u] = value.record.x;
+  output[at + 5u] = value.record.y;
+  output[at + 6u] = value.record.z;
+  output[at + 7u] = value.record.w;
+  output[at + 8u] = value.swing;
 }
 
 @compute @workgroup_size(${RECON_WORKGROUP}, ${RECON_WORKGROUP})
@@ -780,6 +898,12 @@ ${RECON_PARAMS_WGSL}
 @group(0) @binding(6) var<uniform> recon: ReconParams;
 @group(0) @binding(7) var resolved: texture_storage_2d<rgba16float, write>;
 /* Not "target": it is a reserved keyword in WGSL, as "meta" was in the cluster cull. */
+/* Last frame's flicker records, and where this frame's go: a pair beside the histories. */
+@group(0) @binding(8) var flickerTexture: texture_2d<f32>;
+@group(0) @binding(9) var flickerOut: texture_storage_2d<rgba16float, write>;
+/* And each pixel's held depth swing, a pair of its own. */
+@group(0) @binding(10) var swingTexture: texture_2d<f32>;
+@group(0) @binding(11) var swingOut: texture_storage_2d<r32float, write>;
 
 /* Rows flip here: the reference's row 0 is the bottom one and a texture's is the top. */
 fn reconRenderRow(y: i32) -> i32 {
@@ -812,6 +936,14 @@ fn reconHistory(x: i32, y: i32) -> vec4<f32> {
   return textureLoad(historyTexture, vec2<i32>(x, reconOutputRow(y)), 0);
 }
 
+fn reconFlicker(x: i32, y: i32) -> vec4<f32> {
+  return textureLoad(flickerTexture, vec2<i32>(x, reconOutputRow(y)), 0);
+}
+
+fn reconSwing(x: i32, y: i32) -> f32 {
+  return textureLoad(swingTexture, vec2<i32>(x, reconOutputRow(y)), 0).x;
+}
+
 /* A texel coordinate becomes the uv of its centre, with the row taken from the other end. */
 fn reconSceneBilinear(p: vec2<f32>) -> vec3<f32> {
   let size = vec2<f32>(f32(recon.renderSize.x), f32(recon.renderSize.y));
@@ -831,7 +963,9 @@ fn resolveMain(@builtin(global_invocation_id) id: vec3<u32>) {
   if (id.x >= recon.outputSize.x || id.y >= recon.outputSize.y) { return; }
   let y = i32(recon.outputSize.y) - 1 - i32(id.y);
   let value = reconResolvePixel(i32(id.x), y);
-  textureStore(resolved, vec2<i32>(i32(id.x), i32(id.y)), value);
+  textureStore(resolved, vec2<i32>(i32(id.x), i32(id.y)), value.colour);
+  textureStore(flickerOut, vec2<i32>(i32(id.x), i32(id.y)), value.record);
+  textureStore(swingOut, vec2<i32>(i32(id.x), i32(id.y)), vec4<f32>(value.swing, 0.0, 0.0, 0.0));
 }
 
 @compute @workgroup_size(${RECON_WORKGROUP}, ${RECON_WORKGROUP})

package/src/render/shaders/rush.ts

@@ -104,6 +104,16 @@ uniform float uMotionMax;
  */
 uniform sampler2D uAo;
 uniform float uAoStrength;
+/**
+ * Where this frame's jitter put the picture the occlusion was measured from, in this pass's uv.
+ *
+ * The occlusion is measured from the frame's own depth, which a temporal resolve or a
+ * reconstruction jittered, and it is applied here to a picture those have already taken the jitter
+ * out of — so read at the pixel's own uv it moved by the jitter every frame, and every crevice
+ * shimmered by up to half a render texel. Read where the jitter put it, it holds still. Zero for an
+ * unjittered frame.
+ */
+uniform vec2 uAoOffset;
 
 /**
  * The bloom chain's top level, already thresholded, blurred and summed by its own pass.
@@ -341,7 +351,7 @@ void main() {
    * strength, so the parameter reads as "how much of this occlusion", and 0 is exactly the
    * frame that existed before the effect did.
    */
-  float ao = mix(1.0, textureLod(uAo, vUv, 0.0).r, uAoStrength);
+  float ao = mix(1.0, textureLod(uAo, vUv + uAoOffset, 0.0).r, uAoStrength);
 
   /*
    * Distance from the centre, corrected so the falloff is a circle on screen rather than

package/src/render/shaders/sdfText.ts

@@ -30,7 +30,8 @@ precision highp float;
 
 in vec2 vUv;
 
-uniform sampler2D uAtlas;
+/* An array of one: every surface texture is an array, and an atlas is read at layer 0. */
+uniform mediump sampler2DArray uAtlas;
 uniform vec3 uColor;
 uniform float uOpacity;
 /* Texels the field spans, from the atlas metrics. Scales the antialiasing band. */
@@ -52,7 +53,7 @@ float median(vec3 rgb) {
 }
 
 void main() {
-  vec3 sampled = textureLod(uAtlas, vUv, 0.0).rgb;
+  vec3 sampled = textureLod(uAtlas, vec3(vUv, 0.0), 0.0).rgb;
   float distance = median(sampled) - 0.5;
 
   /*

package/src/render/shaders/text.ts

@@ -27,7 +27,7 @@ uniform vec2 uViewport;
 /** Where the string's baseline-left sits, in pixels from the top left. */
 uniform vec2 uOrigin;
 uniform float uCellSize;
-/** Distance from the virtual camera; larger flattens the perspective. */
+/** How far each cell is seen from, head-on; larger flattens the perspective. */
 uniform float uDepth;
 
 /** 0 before a character has arrived, 1 once it has settled. */
@@ -105,14 +105,23 @@ void main() {
   vec2 cell = aCell * uCellSize;
   float bob = sin(uTime * 3.1 + aCharIndex * 0.7) * uBob;
 
-  // Pixels, y down from the top-left corner of the viewport.
-  vec2 screen = uOrigin + vec2(cell.x, -cell.y) + vec2(0.0, rise - bob);
-  vec3 view = vec3(screen + local3.xy, -uDepth + local3.z);
-
-  // A hand-built perspective divide. The near plane is the viewport itself, so
-  // a cell at depth uDepth is exactly its pixel size on screen.
-  float invDepth = uDepth / max(0.001, -view.z);
-  vec2 ndc = ((view.xy * invDepth) / uViewport) * 2.0 - 1.0;
+  // The cell's centre in pixels, y down from the top-left corner of the viewport.
+  vec2 centre = uOrigin + vec2(cell.x, -cell.y) + vec2(0.0, rise - bob);
+
+  // A hand-built perspective divide about the cell's own centre, so every cube
+  // is seen head-on: its front face at depth zero is exactly its cell, and at
+  // rest its sides are behind it wherever on the screen it is drawn.
+  //
+  // It divided about the viewport's top-left corner until 2026-09-30, which
+  // shifted a front face by its distance from that corner times z / uDepth and
+  // showed the side it uncovered. Near the corner that was nothing; across the
+  // screen it widened every stroke by up to a pixel either side and closed the
+  // one-cell gaps a 5x7 face reads by. What this gives up is the extruded look
+  // text far from the corner had at rest; what would make it wrong is a caller
+  // wanting that look, which is then one offset for every cell, not a position.
+  float invDepth = uDepth / max(0.001, uDepth - local3.z);
+  vec2 screen = centre + local3.xy * invDepth;
+  vec2 ndc = (screen / uViewport) * 2.0 - 1.0;
   // Depth from the cube's own extrusion, mapped into a narrow slice of the
   // range so a message sorts against itself without ever reaching the scene.
   float depth = clamp(-local3.z / max(1.0, uCellSize * 2.0), -1.0, 1.0) * 0.4;

package/src/render/shadowCasters.ts

@@ -1,3 +1,4 @@
+import { resolveGlass, type GlassOptions, type ResolvedGlass } from './glass.ts';
 import type { ReadonlyMat4 } from 'gl-matrix';
 import type { InstanceData } from './instancedMesh.ts';
 import type { InstancedHandle, MeshHandle, ScatterHandle } from './backend/api.ts';
@@ -41,7 +42,33 @@ import type { SurfaceTextureHandle } from './backend/api.ts';
  * outwards, so a required parameter added in a minor stops every consumer's sink and every test
  * double compiling. A sink that ignores it behaves exactly as it did.
  */
-export type SceneCasterMaterial = SurfaceMaterial<SurfaceTextureHandle> | null;
+export type SceneCasterMaterial =
+  | (SurfaceMaterial<SurfaceTextureHandle> & {
+      /**
+       * The caster is glass: it lets light through, so it writes no depth into any shadow map and a
+       * lamp behind it lights what is beyond. The colour replay into a mirror or a probe still draws
+       * it. With `RenderQuality.glassShadows` on it casts a coloured shadow instead: see
+       * `glassShadow.ts`.
+       */
+      readonly glass?: GlassOptions;
+    })
+  | null;
+
+/**
+ * Whether a caster writes depth into a shadow map: everything but glass. One line in each depth
+ * sink, so the answer is the same in every shadow a backend draws.
+ */
+export function castsDepth(material: SceneCasterMaterial | undefined): boolean {
+  return (material?.glass?.transmission ?? 0) <= 0;
+}
+
+/**
+ * The caster's glass, resolved into `out`, and whether it is glass at all — the rule `castsDepth`
+ * states from the other side, so a caster is exactly one of the two.
+ */
+export function glassOf(material: SceneCasterMaterial | undefined, out: ResolvedGlass): boolean {
+  return resolveGlass(material?.glass, out);
+}
 
 export interface ShadowCasterSink {
   /** A rigid mesh at a model transform: the world, a prop, a static piece of scenery. */