@driftengine/core 4.4.1 → 4.5.0

package/src/render/pointShadowArray.ts

@@ -2,6 +2,7 @@ import { mat3 } from 'gl-matrix';
 
 import { createEmptyTexture2D } from './emptyTexture.ts';
 import { LIVE_POINT_SHADOW_MAPS, POINT_SHADOW_POOL } from './lightBudget.ts';
+import { PointGlassTint } from './pointGlassTint.ts';
 import { pointShadowFaceRotation } from './pointShadowImage.ts';
 import { compileProgram, uniformLocations } from './shader.ts';
 import { OCTAHEDRAL_RESOLVE_FRAG, OCTAHEDRAL_RESOLVE_VERT } from './shaders/octahedralResolve.ts';
@@ -34,6 +35,37 @@ export interface PointShadowTarget {
     far: number,
     near: number,
   ): void;
+  /** Whether the array has grown its glass layers: `growForGlass`. */
+  readonly hasGlass: boolean;
+  /** Whether `face` of `layer` holds glass, which a face that offers none must clear. */
+  heldGlass(layer: number, face: number): boolean;
+  /** The depth scratch again, cleared, for the face's glass. */
+  beginGlassFace(gl: WebGL2RenderingContext): void;
+  resolveGlassFace(
+    gl: WebGL2RenderingContext,
+    layer: number,
+    face: number,
+    far: number,
+    near: number,
+  ): void;
+  /** The colour scratch, cleared to white, for what the face's glass lets through. */
+  beginTintFace(gl: WebGL2RenderingContext): void;
+  resolveTintFace(gl: WebGL2RenderingContext, layer: number, face: number, drawn: boolean): void;
+}
+
+/**
+ * Every published layer as the array stores it: `layer × stride`, and −1 left as −1.
+ *
+ * **Applied to the resolved arrays right after each resolve**, so every consumer of an uploaded
+ * index reads the physical layer: once glass arrives, light L's depth is at 2L and its glass at
+ * 2L + 1 (`PointShadowArray.growForGlass`). In place, because the resolve rewrites these every time.
+ */
+export function strideLayers(layers: Int32Array, stride: number): void {
+  if (stride === 1) return;
+  for (let i = 0; i < layers.length; i++) {
+    const layer = layers[i] as number;
+    if (layer >= 0) layers[i] = layer * stride;
+  }
 }
 
 /**
@@ -53,12 +85,16 @@ export interface PointShadowTarget {
  * never the same object.
  */
 export class PointShadowArray implements PointShadowTarget {
-  readonly texture: WebGLTexture;
   /**
-   * How many layers this array holds: the point pool, the two live transition maps, and two more
-   * for each rectangle a world said would cast. See the constructor's `extraLayers`.
+   * How many lights this array holds: the point pool, the two live transition maps, and two more
+   * for each rectangle a world said would cast. See the constructor's `extraLayers`. Counted in
+   * lights, so it does not move when glass doubles the storage under it.
    */
   readonly layers: number;
+  /** Replaced once, when glass first casts: see `growForGlass`. */
+  private current: WebGLTexture;
+  /** What the lights' glass lets through, made with the glass layers. */
+  private tint: PointGlassTint | null = null;
 
   private readonly framebuffer: WebGLFramebuffer;
   private readonly scratchTexture: WebGLTexture;
@@ -96,23 +132,8 @@ export class PointShadowArray implements PointShadowTarget {
     this.layers =
       Math.min(lightCount, POINT_SHADOW_POOL) + LIVE_POINT_SHADOW_MAPS + Math.max(0, extraLayers);
 
-    const texture = gl.createTexture();
-    if (texture === null) throw new Error('PointShadowArray: createTexture failed');
-    this.texture = texture;
-    gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture);
-    gl.texStorage3D(
-      gl.TEXTURE_2D_ARRAY,
-      1,
-      gl.DEPTH_COMPONENT24,
-      OCTAHEDRAL_EDGE,
-      OCTAHEDRAL_EDGE,
-      this.layers,
-    );
-    /* One storage level and no filtering, so textureLod(..., 0.0) is the only fetch there is. */
-    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const texture = depthArray(gl, this.layers);
+    this.current = texture;
 
     const scratchTexture = gl.createTexture();
     if (scratchTexture === null) throw new Error('PointShadowArray: createTexture failed');
@@ -183,6 +204,117 @@ export class PointShadowArray implements PointShadowTarget {
     gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
   }
 
+  /** The array texture the lit pass samples. Replaced once, when glass first casts. */
+  get texture(): WebGLTexture {
+    return this.current;
+  }
+
+  get hasGlass(): boolean {
+    return this.tint !== null;
+  }
+
+  /** Physical layers a light: 1, or 2 once glass has interleaved the array. */
+  get stride(): number {
+    return this.tint === null ? 1 : 2;
+  }
+
+  /** The glass tint, one layer a light, once glass has cast; the lit pass samples it. */
+  get tintTexture(): WebGLTexture | null {
+    return this.tint?.texture ?? null;
+  }
+
+  /**
+   * Interleave the array for glass: light L's depth moves to 2L and its glass takes 2L + 1, and
+   * the tint is made. Returns whether it grew — once, on the first face whose casters held glass.
+   *
+   * **Interleaved rather than stacked above the opaque half** because a shader cannot ask an array
+   * its layer count under naga, so it cannot find `L + N`; `layer + 1` it can. **Every map already
+   * baked is carried across** by a depth blit, so nothing goes dark, and **no map needs baking
+   * again**: this runs on the first face that saw glass, so no map baked before it saw any, and a
+   * glass layer born at the far plane with a white tint is exactly what its bake would draw. What
+   * it costs is the doubled depth (4.19 MB a light at 1024) and the tint (5.6 MB a light with its
+   * chain, 1.4 MB at `'half'`), from then on.
+   */
+  growForGlass(gl: WebGL2RenderingContext, tintEdge: number): boolean {
+    if (this.tint !== null) return false;
+    const old = this.current;
+    const texture = depthArray(gl, this.layers * 2);
+    /* Off the unit it was made on, as the constructor leaves its own: see `beginFace`. */
+    gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+    const read = gl.createFramebuffer();
+    if (read === null) throw new Error('PointShadowArray: createFramebuffer failed');
+    gl.bindFramebuffer(gl.READ_FRAMEBUFFER, read);
+    gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.framebuffer);
+    for (let layer = 0; layer < this.layers; layer++) {
+      gl.framebufferTextureLayer(gl.READ_FRAMEBUFFER, gl.DEPTH_ATTACHMENT, old, 0, layer);
+      gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.DEPTH_ATTACHMENT, texture, 0, 2 * layer);
+      gl.blitFramebuffer(
+        0,
+        0,
+        OCTAHEDRAL_EDGE,
+        OCTAHEDRAL_EDGE,
+        0,
+        0,
+        OCTAHEDRAL_EDGE,
+        OCTAHEDRAL_EDGE,
+        gl.DEPTH_BUFFER_BIT,
+        gl.NEAREST,
+      );
+    }
+    /* Nothing is nearer a lamp than a pane that has not been drawn. */
+    for (let layer = 0; layer < this.layers; layer++) {
+      gl.framebufferTextureLayer(
+        gl.DRAW_FRAMEBUFFER,
+        gl.DEPTH_ATTACHMENT,
+        texture,
+        0,
+        2 * layer + 1,
+      );
+      gl.clearBufferfv(gl.DEPTH, 0, FAR_PLANE);
+    }
+    gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.deleteFramebuffer(read);
+    gl.deleteTexture(old);
+    this.current = texture;
+    this.tint = new PointGlassTint(gl, this.faceSize, tintEdge, this.layers);
+    return true;
+  }
+
+  heldGlass(layer: number, face: number): boolean {
+    return this.tint?.held(layer, face) ?? false;
+  }
+
+  /** The depth scratch, cleared, for the face's glass: `beginFace` exactly. */
+  beginGlassFace(gl: WebGL2RenderingContext): void {
+    this.beginFace(gl);
+  }
+
+  /** The face's glass depth into light `layer`'s glass layer, 2L + 1. */
+  resolveGlassFace(
+    gl: WebGL2RenderingContext,
+    layer: number,
+    face: number,
+    far: number,
+    near: number,
+  ): void {
+    if (this.tint === null) return;
+    this.resolveInto(gl, 2 * layer + 1, face, far, near);
+  }
+
+  beginTintFace(gl: WebGL2RenderingContext): void {
+    this.tint?.beginFace(gl);
+  }
+
+  resolveTintFace(gl: WebGL2RenderingContext, layer: number, face: number, drawn: boolean): void {
+    this.tint?.resolveFace(gl, layer, face, drawn);
+  }
+
+  /** The chain frost reads, for every light whose tint a round touched: once a round. */
+  finishTints(gl: WebGL2RenderingContext): void {
+    this.tint?.fillMips(gl);
+  }
+
   /**
    * Bind the scratch as the render target for one face of one bake, and clear it.
    *
@@ -224,9 +356,20 @@ export class PointShadowArray implements PointShadowTarget {
     face: number,
     far: number,
     near: number,
+  ): void {
+    this.resolveInto(gl, layer * this.stride, face, far, near);
+  }
+
+  /** The scratch into physical layer `physical`'s region for `face`. */
+  private resolveInto(
+    gl: WebGL2RenderingContext,
+    physical: number,
+    face: number,
+    far: number,
+    near: number,
   ): void {
     gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
-    gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, this.texture, 0, layer);
+    gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, this.current, 0, physical);
     gl.viewport(0, 0, OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE);
 
     gl.useProgram(this.program);
@@ -267,10 +410,33 @@ export class PointShadowArray implements PointShadowTarget {
   dispose(gl: WebGL2RenderingContext): void {
     gl.deleteFramebuffer(this.framebuffer);
     gl.deleteFramebuffer(this.scratchFramebuffer);
-    gl.deleteTexture(this.texture);
+    gl.deleteTexture(this.current);
     gl.deleteTexture(this.scratchTexture);
+    this.tint?.dispose(gl);
     gl.deleteTexture(this.parked);
     gl.deleteProgram(this.program);
     gl.deleteVertexArray(this.vao);
   }
 }
+
+const FAR_PLANE = new Float32Array([1]);
+
+/** The depth array: one storage level and no filtering, so textureLod(..., 0.0) is the only fetch. */
+function depthArray(gl: WebGL2RenderingContext, layers: number): WebGLTexture {
+  const texture = gl.createTexture();
+  if (texture === null) throw new Error('PointShadowArray: createTexture failed');
+  gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture);
+  gl.texStorage3D(
+    gl.TEXTURE_2D_ARRAY,
+    1,
+    gl.DEPTH_COMPONENT24,
+    OCTAHEDRAL_EDGE,
+    OCTAHEDRAL_EDGE,
+    layers,
+  );
+  gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  return texture;
+}

package/src/render/pointShadowBudget.ts

@@ -256,15 +256,15 @@ export function runPointShadowBakes<M extends StaleCheck, L extends BakeableLigh
      * **The run decays rather than resetting, and it climbs past the threshold before it stops.**
      *
      * A light that wanders on a curve is not stale on *every* frame — near the turning points of
-     * its travel it moves less in a frame than the rebake tolerance, so a run that reset to zero
-     * lost the tracking allowance there and the map dropped back to two faces a frame. The shadow
-     * then travelled smoothly through the fast part of the wander and stepped through the slow
-     * part, which is not motion and not stillness: it reads as a vibration. Reported that way,
-     * against a brazier, once the tracking allowance was in.
+     * its travel it moves less in a frame than the rebake tolerance. When the run decided whether a
+     * wanderer got its whole cube, a run that reset to zero dropped it back to two faces a frame
+     * there, and the shadow stepped through the slow part of the wander: reported as a vibration
+     * against a brazier. Every image-holding map is re-baked whole now, so the run only orders the
+     * queue, and the hysteresis keeps a wanderer behind the lights that settle instead of letting
+     * it jump ahead at every turning point.
      *
-     * So the run is hysteresis. It climbs to twice the threshold, which buys a light that has
-     * earned the allowance three quiet frames before it loses it, and decays one frame at a time
-     * so a light that genuinely settles stops re-baking rather than holding a budget for ever.
+     * It climbs to twice the threshold, which keeps a light chronic for three quiet frames, and
+     * decays one frame at a time so a light that genuinely settles rejoins the ordinary order.
      */
     const previous = scratch.staleRun[slot] ?? 0;
     const run = stale
@@ -285,37 +285,40 @@ export function runPointShadowBakes<M extends StaleCheck, L extends BakeableLigh
   let faces = facesPerFrame;
   let urgentSpent = false;
   /*
-   * **One wandering light finishes its cube in the frame it started it**, the same allowance a
-   * light with no image at all gets, and for a reason that turns out to be the same one: a map
-   * dribbled out at two faces a frame is a map nobody can sample correctly until it lands.
+   * **A map that holds an image is re-baked whole or not at all**, and one being shaded may take a
+   * whole cube a frame outside the budget to make that possible.
    *
-   * A cold light cannot be sampled *at all* until its six faces are in, so it takes the whole
-   * cube at once. A chronically stale one can be sampled throughout and is wrong in a quieter
-   * way: `planBake` pins the origin for the whole of a resumed bake, so six faces spread over
-   * three frames means the published origin steps once every third frame. The shader shoots from
-   * that origin, so the shadow it draws steps with it — reported on a brazier as motion that was
-   * "really fast, not smooth, snappy, and unrealistic", which is a 20 Hz sample of a flame that
-   * wanders about once a second.
+   * Faces land in the layer the shader samples as they are drawn, and `planBake` publishes the
+   * origin they were drawn from only with the last one. So a re-bake spread over frames is a cube
+   * the shader reads from the old origin with part of it drawn from the new one — and a face is a
+   * 90 degree frustum, so the part drawn from somewhere else is a straight-edged quadrilateral of
+   * wrong shadow on the ground under the lamp. With the budget spent elsewhere it could hold for a
+   * second and more. Reported under a brazier as a dark shape that came and went.
    *
-   * Given the cube in one frame the origin moves every frame and the shadow travels instead.
+   * A map with no image yet is not sampled until its sixth face lands (see
+   * `PointShadowSystem.bind`), so it still fills a few faces a frame, and a cold one being shaded
+   * still jumps the queue with all six.
    *
-   * **Bounded to one light, and it has to be.** Eight braziers each taking six passes is the 48
-   * passes and 89 ms `pointShadowFacesPerFrame` exists to prevent. One is the light being shaded
-   * that most recently went stale, which is the one somebody is standing next to; the rest keep
-   * dribbling under the ordinary budget, and their shadows step rather than travel. That is the
-   * right way round: a shadow you are looking at moves, and a shadow across the square does not
-   * cost the frame.
+   * The allowance used to be for a *chronically* stale light only — a wandering flame — whose
+   * dribbled cube published a new origin once every third frame, so its shadow stepped at 20 Hz
+   * where the flame wanders about once a second: reported as motion that was "really fast, not
+   * smooth, snappy, and unrealistic". Any shaded light is owed the same now, because a cube read
+   * part-way is wrong in the same place for the same reason whether or not it will be stale again.
    *
-   * It is spent *after* the cold and settling groups, because `planPointShadowBakes` orders the
-   * chronic ones last — so a light arriving in range still gets its first image ahead of a flame
-   * refining one it already has.
+   * **Bounded to one light, and it has to be.** Eight braziers each taking six passes is the 48
+   * passes and 89 ms `pointShadowFacesPerFrame` exists to prevent. The first in the plan's order
+   * takes it, and `planPointShadowBakes` puts the lights that settled ahead of the ones that never
+   * do, so a flame refining its image cannot hold a correction hostage. The rest keep sampling a
+   * complete image from a few centimetres away until their turn, which is the trade
+   * `pointShadowRebakeDistance` already makes. A warm map, held but not shaded, is re-baked when a
+   * whole cube fits the budget or once it is shaded, and not before.
    *
-   * **What would make it wrong** is a caster set heavy enough that six passes over it does not
-   * fit the frame. Measured against a game whose whole static world is about 8,500 triangles in
-   * a handful of draws; a world an order of magnitude heavier wants `pointShadowFacesPerFrame`
+   * **What would make it wrong** is a caster set heavy enough that six passes over it does not fit
+   * the frame. Measured against a game whose whole static world is about 8,500 triangles in a
+   * handful of draws; a world an order of magnitude heavier wants `pointShadowFacesPerFrame`
    * raised or this given up, and `gpuTiming` is how to tell which.
    */
-  let trackingSpent = false;
+  let refreshSpent = false;
   for (let i = 0; i < planned && faces > 0; i++) {
     const slot = scratch.order[i] ?? -1;
     /*
@@ -328,13 +331,20 @@ export function runPointShadowBakes<M extends StaleCheck, L extends BakeableLigh
     if (light === undefined || map === undefined) continue;
 
     const sampled = slot < pool.sampledCount;
-    const cold = sampled && scratch.ready[slot] === 0;
-    const urgent = cold && !urgentSpent;
-    /* A light being shaded whose map will be stale again next frame however it is served. */
-    const tracking = !cold && sampled && scratch.chronic[slot] === 1 && !trackingSpent;
-    if (urgent) urgentSpent = true;
-    if (tracking) trackingSpent = true;
-    faces -= bake(map, light, staticCasters, urgent || tracking ? faceCount : faces);
+    if (scratch.ready[slot] !== 1) {
+      /* No image to spoil: a few faces a frame, or all six at once for one being shaded. */
+      const urgent = sampled && !urgentSpent;
+      if (urgent) urgentSpent = true;
+      faces -= bake(map, light, staticCasters, urgent ? faceCount : faces);
+      continue;
+    }
+    if (faces >= faceCount) {
+      faces -= bake(map, light, staticCasters, faceCount);
+      continue;
+    }
+    if (!sampled || refreshSpent) continue;
+    refreshSpent = true;
+    faces -= bake(map, light, staticCasters, faceCount);
   }
 
   /*

package/src/render/pointShadowMap.ts

@@ -36,6 +36,19 @@ export { FACE_COUNT, POINT_SHADOW_NEAR };
 
 const scratchViewProj = mat4.create();
 
+/**
+ * What a bake asks of the renderer about glass, after each face's opaque depth.
+ *
+ * **Asked before it is drawn** because the answer decides whether the face binds a glass target at
+ * all: a face that offers no glass and holds none from a previous owner does no glass work.
+ */
+export interface PointGlassDraw {
+  /** Whether the face just drawn offered any glass. */
+  offered(): boolean;
+  /** Draw that glass: its depth, or what it lets through lit from the bake origin. */
+  draw(pass: 'depth' | 'tint', x: number, y: number, z: number): void;
+}
+
 export class PointShadowMap {
   readonly size: number;
   /**
@@ -163,6 +176,8 @@ export class PointShadowMap {
     near = POINT_SHADOW_NEAR,
     sourceRadius = DEFAULT_SOURCE_RADIUS,
     maxFaces = FACE_COUNT,
+    /** The face's glass, when glass shadows are on: `PointGlassDraw`. */
+    glass: PointGlassDraw | null = null,
   ): number {
     /*
      * What to render now, **and what to render it for**. A bake in flight owns the parameters
@@ -220,6 +235,7 @@ export class PointShadowMap {
        * next face's pass does care about.
        */
       array.resolveFace(gl, this.layer, face, plan.range, plan.near);
+      if (glass !== null) this.bakeGlassFace(gl, array, glass, face, plan);
     }
 
     gl.enable(gl.CULL_FACE);
@@ -237,5 +253,30 @@ export class PointShadowMap {
    * needing disposal is exactly the shape of a leak nobody notices. The array is disposed by the
    * renderer that built it.
    */
+  /**
+   * The face's glass, twice: where the nearest pane is, then what the panes let through.
+   *
+   * A face that offers no glass still clears a region a previous owner's glass is in — the depth to
+   * the far plane and the tint to white, from scratches cleared and not drawn into — because a pool
+   * slot changes hands with its layer.
+   */
+  private bakeGlassFace(
+    gl: WebGL2RenderingContext,
+    array: PointShadowTarget,
+    glass: PointGlassDraw,
+    face: number,
+    plan: FaceRange,
+  ): void {
+    if (!array.hasGlass) return;
+    const offered = glass.offered();
+    if (!offered && !array.heldGlass(this.layer, face)) return;
+    array.beginGlassFace(gl);
+    if (offered) glass.draw('depth', plan.x, plan.y, plan.z);
+    array.resolveGlassFace(gl, this.layer, face, plan.range, plan.near);
+    array.beginTintFace(gl);
+    if (offered) glass.draw('tint', plan.x, plan.y, plan.z);
+    array.resolveTintFace(gl, this.layer, face, offered);
+  }
+
   dispose(_gl: WebGL2RenderingContext): void {}
 }

package/src/render/recon/changeFrames.ts

@@ -0,0 +1,24 @@
+/**
+ * Which frame a change to a dynamic mesh or an instanced batch belongs to.
+ *
+ * **A consumer may change geometry in its simulation step, before `beginFrame`.** That change is
+ * what the *next* frame draws, so it is that frame's — counting it against the frame last begun
+ * would say the geometry changed a frame early and then did not change at all, which is a motion
+ * vector on the wrong frame and none on the right one.
+ *
+ * Only the **first** change in a frame keeps the state before it: a second rewrite in the same
+ * frame must not replace "where it was last frame" with "where it was a moment ago".
+ */
+
+export function frameOfChange(serial: number, inFrame: boolean): number {
+  return inFrame ? serial : serial + 1;
+}
+
+export function keepsPrevious(lastChange: number, frame: number): boolean {
+  return lastChange !== frame;
+}
+
+/** Slots `0 … n-1` pair with last frame's; a slot past last frame's count is new and has no past. */
+export function pairedInstances(previousCount: number, count: number): number {
+  return Math.min(previousCount, count);
+}

package/src/render/recon/disocclusion.ts

@@ -12,10 +12,15 @@
  * a different part of a texel than the one it stands for, which at a grazing angle is a different
  * depth; the tolerance grows with the motion's length.
  *
+ * **And in proportion to the surface's own slope.** A new jitter samples a surface somewhere else, so
+ * on one turned from the eye two frames' samples of it differ by up to a texel's worth of its depth
+ * with nothing moved. `surfaceSlope` measures that step on the surface's own side of any silhouette.
+ *
  * **Normals, for the case depth cannot see.** A leaf's two sides are at one depth, and the history of
  * the front is not the back. The forward frame has no normal buffer, so both normals come from their
  * frame's depth — `worldPositionFromDepth` and `normalFromPositions` — in world space, where the two
- * frames agree.
+ * frames agree. **A normal differenced across an edge is not a normal**, so the caller weighs each by
+ * `planarity`: at an edge, a sliver, or anything finer than a texel the depth test decides alone.
  *
  * **Continuous in every input**, because a step is a line on screen along which the history is kept on
  * one frame and dropped on the next: every threshold is a smoothstep, never a comparison.
@@ -51,12 +56,57 @@ function smoothstep(edge0: number, edge1: number, x: number): number {
   return t * t * (3 - 2 * t);
 }
 
+/**
+ * The band over which three texels stop being one plane: how far their two steps in inverse depth
+ * fail to cancel, as a share of the two together. None of it is a plane at any angle; all of it is an
+ * edge — one side steps, the other does not — or a sliver, both stepping the same way.
+ *
+ * **A share and not a size**, which is the lesson of the rods in `resolve.test.ts`: a part a
+ * hundredth of the depth in front of a wall passes the depth test, and a normal differenced across it
+ * still leans by its height over a texel's width — nearly edge-on where texels are small. What would
+ * make this wrong is a curved surface judged at its apex, where both steps lean one way and the
+ * normal is sound; there it only gives the normals less say, which the depth test does not need.
+ */
+export const PLANAR_FROM = 0.25;
+export const PLANAR_TO = 0.5;
+
+/**
+ * How sure it is that `centre` and its neighbours either side along one axis lie on one plane, one to
+ * zero. Inverse depth is affine across a plane on screen, so a plane's two steps cancel whatever its
+ * angle. One where a neighbour is missing — zero, off the picture or undrawn — or where there is no
+ * step to compare: nothing to judge by, so a normal keeps the say it always had.
+ */
+export function planarity(before: number, centre: number, after: number): number {
+  if (!(before > 0) || !(centre > 0) || !(after > 0)) return 1;
+  const a = 1 / after - 1 / centre;
+  const b = 1 / before - 1 / centre;
+  const spread = Math.abs(a) + Math.abs(b);
+  if (!(spread > 0)) return 1;
+  return 1 - smoothstep(PLANAR_FROM, PLANAR_TO, Math.abs(a + b) / spread);
+}
+
+/**
+ * How far a surface's depth moves across one texel along an axis, relative to the depth: the smaller
+ * of the steps to its two neighbours, because beside a silhouette one of them is the surface behind.
+ * Zero at a sliver — nearer or farther than both, so each step is to another surface — and one
+ * neighbour's step where only one is there.
+ */
+export function surfaceSlope(before: number, centre: number, after: number): number {
+  const a = after > 0 ? after - centre : Number.NaN;
+  const b = before > 0 ? before - centre : Number.NaN;
+  if (Number.isNaN(a)) return Number.isNaN(b) ? 0 : Math.abs(b) / centre;
+  if (Number.isNaN(b)) return Math.abs(a) / centre;
+  if (a * b > 0) return 0;
+  return Math.min(Math.abs(a), Math.abs(b)) / centre;
+}
+
 /**
  * One where the history is trustworthy, zero where it is not, and continuous between.
  *
  * `currDepth` is the view depth this surface should have had last frame; `histDepth` the view depth
  * last frame held where it lands, or zero where it landed off the screen; `motionLength` the motion's
- * length in uv; `normalDot` the cosine between the two frames' world normals there.
+ * length in uv; `normalDot` the cosine between the two frames' world normals there; `slope` the
+ * surface's `surfaceSlope`, which widens the tolerance one for one.
  */
 export function disocclusionWeight(
   currDepth: number,
@@ -64,12 +114,13 @@ export function disocclusionWeight(
   motionLength: number,
   normalDot: number,
   params: DisocclusionParams,
+  slope = 0,
 ): number {
   if (!(currDepth > 0) || !(histDepth > 0) || !(motionLength >= 0) || Number.isNaN(normalDot)) {
     return 0;
   }
   const disagreement = Math.abs(currDepth - histDepth) / currDepth;
-  const tolerance = params.depthTolerance + params.motionScale * motionLength;
+  const tolerance = params.depthTolerance + params.motionScale * motionLength + slope;
   const depth = 1 - smoothstep(tolerance, 2 * tolerance, disagreement);
   const normal = smoothstep(params.normalFloor, params.normalCeiling, normalDot);
   return depth * normal;

package/src/render/recon/lateRouting.ts

@@ -0,0 +1,29 @@
+/**
+ * Two decisions about one draw in a reconstructing frame, and why they are the same set.
+ *
+ * A blended draw goes **late** — after the reconstruction, at output resolution, unjittered — and a
+ * mover's motion is **tracked**, only for draws that land in the picture being reconstructed. A
+ * planar mirror and a probe bake are other pictures drawn through the same verbs, and the overlay
+ * after `endFrame` is past the picture altogether; routing any of them late, or counting a mirrored
+ * draw as a mover's second draw of the frame, would be wrong in the way that reads as a ghost.
+ *
+ * Plain booleans rather than a state object, so the per-draw call allocates nothing.
+ */
+export function routesLate(
+  reconstructing: boolean,
+  mirror: boolean,
+  probe: boolean,
+  presented: boolean,
+): boolean {
+  return reconstructing && !mirror && !probe && !presented;
+}
+
+/** The same set as `routesLate`, named for the other reader. */
+export function tracksMotion(
+  reconstructing: boolean,
+  mirror: boolean,
+  probe: boolean,
+  presented: boolean,
+): boolean {
+  return routesLate(reconstructing, mirror, probe, presented);
+}