@driftengine/core 4.4.0 → 4.4.2

package/src/render/backend/webgpu/postPass.ts

@@ -331,7 +331,37 @@ export function postPipeline(
   format: GPUTextureFormat,
   blend?: GPUBlendState,
 ): GPURenderPipeline {
-  return cache.get(key, () => ({
+  return cache.get(key, () =>
+    describePost(device, layout, key, fragment, [
+      blend === undefined ? { format } : { format, blend },
+    ]),
+  );
+}
+
+/**
+ * The same over several colour targets, in the fragment's output order: the temporal resolve
+ * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
+ * rather than built per call, since this is asked for every frame.
+ */
+export function postPipelineTargets(
+  cache: PipelineCache,
+  device: GPUDevice,
+  layout: GPUBindGroupLayout,
+  key: string,
+  fragment: string,
+  targets: GPUColorTargetState[],
+): GPURenderPipeline {
+  return cache.get(key, () => describePost(device, layout, key, fragment, targets));
+}
+
+function describePost(
+  device: GPUDevice,
+  layout: GPUBindGroupLayout,
+  key: string,
+  fragment: string,
+  targets: GPUColorTargetState[],
+): GPURenderPipelineDescriptor {
+  return {
     label: key,
     layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
     vertex: {
@@ -341,7 +371,7 @@ export function postPipeline(
     fragment: {
       module: shaderModule(device, { label: key, code: fragment }),
       entryPoint: 'main',
-      targets: [blend === undefined ? { format } : { format, blend }],
+      targets,
     },
     /*
      * No depth at all, which is what makes this different from every other pipeline here: the
@@ -349,11 +379,11 @@ export function postPipeline(
      * disables the test, the write and culling by hand for the same draw.
      */
     primitive: { topology: 'triangle-list' as const, cullMode: 'none' as const },
-  }));
+  };
 }
 
 /**
- * The temporal resolve's block and its three inputs.
+ * The temporal resolve's block and its four inputs.
  *
  * Named like the occlusion's beside it, and for the same reason `BLOOM_DOWNSAMPLE_FIELDS` is: a
  * block read by assumption rather than by name is a uniform written to the wrong offset, which

package/src/render/backend/webgpu/renderer.ts

@@ -181,6 +181,7 @@ import { reflectionTargetSize, type ReflectionSize } from '../../planarReflectio
 import { drawingBufferSize } from '../../drawingBuffer.ts';
 import { MOTION_BLUR_MAX_UV, OUTPUT_TRANSFORM_CODE, RUSH_REACH_UV } from '../../vertexDefaults.ts';
 import { ExposurePass } from './exposurePass.ts';
+import { AO_STORE } from '../../shaders/ambientOcclusion.ts';
 import { clampAutoExposure } from '../../shaders/exposure.ts';
 import { clampLocalExposure } from '../../shaders/localExposure.ts';
 import type { UniformFields } from './scatterPass.ts';
@@ -189,6 +190,7 @@ import {
   createPostStageLayout,
   depthResolvePipeline,
   postPipeline,
+  postPipelineTargets,
   sceneColorFormat,
   AO_BLUR_FIELDS,
   AO_BLUR_FRAG_WGSL,
@@ -1925,6 +1927,16 @@ export class WebGPURenderer implements RendererApi {
   private taaUniforms!: GPUBuffer;
   private taaTextures: (GPUTexture | null)[] = [null, null];
   private taaViews: (GPUTextureView | null)[] = [null, null];
+  /** Each pixel's flicker record, paired with the history and swapped with it: see `temporalAa.ts`. */
+  private taaRecords: (GPUTexture | null)[] = [null, null];
+  private taaRecordViews: (GPUTextureView | null)[] = [null, null];
+  /** The rest of each pixel's record — depth, pull and recent swing — beside the first. */
+  private taaMotions: (GPUTexture | null)[] = [null, null];
+  private taaMotionViews: (GPUTextureView | null)[] = [null, null];
+  /** The resolve's depth-to-metres row, from the inverse of `frameProjection`. */
+  private readonly taaInvProjection = new Float32Array(16);
+  /** The resolve's two targets, the picture and the record, held for the pipeline cache's sake. */
+  private taaTargets: GPUColorTargetState[] = [];
   /** Group `i` reads history `i` and the pass writes into the other one. */
   private taaBindGroups: (GPUBindGroup | null)[] = [null, null];
   private taaWrite = 0;
@@ -6394,6 +6406,8 @@ export class WebGPURenderer implements RendererApi {
     this.taaLayout = createPostStageLayout(device, TAA_UNIFORMS, TAA_FRAG_SIZE, [
       { binding: TAA_TEXTURES.uScene },
       { binding: TAA_TEXTURES.uHistory },
+      { binding: TAA_TEXTURES.uFlicker },
+      { binding: TAA_TEXTURES.uFlickerMotion },
       { binding: TAA_TEXTURES.uDepth, filterable: false },
     ]);
     this.taaUniforms = device.createBuffer({
@@ -10467,8 +10481,10 @@ export class WebGPURenderer implements RendererApi {
     if (!this.temporalJittering) return;
     const write = this.taaWrite;
     const target = this.taaViews[write];
+    const record = this.taaRecordViews[write];
+    const motion = this.taaMotionViews[write];
     const group = this.taaBindGroups[1 - write];
-    if (target === null || group === null) return;
+    if (target === null || record === null || motion === null || group === null) return;
     const { device } = this.surface;
 
     const f = this.taaFloats;
@@ -10477,6 +10493,22 @@ export class WebGPURenderer implements RendererApi {
     f[at('uTexel')] = 1 / this.renderWidth;
     f[at('uTexel') + 1] = 1 / this.renderHeight;
     f[at('uHistoryBlend')] = this.temporalHistoryUsable ? TEMPORAL_HISTORY_BLEND : 0;
+    f[at('uPeriodStart')] = this.temporalHistory.periodStart ? 1 : 0;
+    /* The anti-flicker's same-surface test reads depths in metres, as the occlusion does. */
+    const depthRow = at('uDepthToViewZ');
+    if (this.frameProjection !== null) {
+      mat4.invert(this.taaInvProjection, this.frameProjection);
+      f[depthRow] = this.taaInvProjection[10] ?? 0;
+      f[depthRow + 1] = this.taaInvProjection[14] ?? 0;
+      f[depthRow + 2] = this.taaInvProjection[11] ?? 0;
+      f[depthRow + 3] = this.taaInvProjection[15] ?? 1;
+    } else {
+      f[depthRow] = 0;
+      f[depthRow + 1] = 0;
+      f[depthRow + 2] = 0;
+      f[depthRow + 3] = 1;
+    }
+    f[at('uAntiFlicker')] = 1;
     device.queue.writeBuffer(this.taaUniforms, 0, this.taaStaging);
 
     const pass = encoder.beginRenderPass({
@@ -10484,16 +10516,18 @@ export class WebGPURenderer implements RendererApi {
       timestampWrites: this.gpuTimer.writesFor(),
       colorAttachments: [
         { view: target, loadOp: 'clear', storeOp: 'store', clearValue: [0, 0, 0, 1] },
+        { view: record, loadOp: 'clear', storeOp: 'store', clearValue: [0, 0, 0, 0] },
+        { view: motion, loadOp: 'clear', storeOp: 'store', clearValue: [0, 0, 0, 0] },
       ],
     });
     pass.setPipeline(
-      postPipeline(
+      postPipelineTargets(
         this.pipelines,
         device,
         this.taaLayout,
         'post.taa',
         TEMPORAL_RESOLVE_FRAG_WGSL,
-        sceneColorFormat(this.quality.hdrScene),
+        this.taaTargets,
       ),
     );
     pass.setBindGroup(0, group, [0]);
@@ -11045,12 +11079,15 @@ export class WebGPURenderer implements RendererApi {
        otherwise halve the blur and leave half the pattern standing. */
     const width = Math.max(1, this.aoTarget?.width ?? 1);
     const height = Math.max(1, this.aoTarget?.height ?? 1);
-    for (const [index, step] of [
-      [0, [1 / width, 0]],
-      [1, [0, 1 / height]],
+    /* Across at the estimate's own scale, which the second axis needs whole; down decoded, so the
+       composite reads open sky as one. The same two `ambientOcclusionPass.ts` writes. */
+    for (const [index, step, scale] of [
+      [0, [1 / width, 0], 1],
+      [1, [0, 1 / height], 1 / AO_STORE],
     ] as const) {
       f[slot(index) + at('uStep')] = step[0];
       f[slot(index) + at('uStep') + 1] = step[1];
+      f[slot(index) + at('uAoScale')] = scale;
       f[slot(index) + at('uDepthToViewZ')] = inv[10] ?? 0;
       f[slot(index) + at('uDepthToViewZ') + 1] = inv[14] ?? 0;
       f[slot(index) + at('uDepthToViewZ') + 2] = inv[11] ?? 0;
@@ -14547,7 +14584,28 @@ export class WebGPURenderer implements RendererApi {
       });
       this.taaTextures[i] = texture;
       this.taaViews[i] = texture.createView();
+      /* The records in half float, whatever the picture's format: one of them holds metres. */
+      this.taaRecords[i]?.destroy();
+      const record = device.createTexture({
+        label: `post.taaRecord${i}`,
+        size: [width, height],
+        format: 'rgba16float',
+        usage: USAGE,
+      });
+      this.taaRecords[i] = record;
+      this.taaRecordViews[i] = record.createView();
+      this.taaMotions[i]?.destroy();
+      /* Two numbers a pixel: the depth its sample stood at, in metres, and how far that swings. */
+      const motion = device.createTexture({
+        label: `post.taaMotion${i}`,
+        size: [width, height],
+        format: 'rg16float',
+        usage: USAGE,
+      });
+      this.taaMotions[i] = motion;
+      this.taaMotionViews[i] = motion.createView();
     }
+    this.taaTargets = [{ format }, { format: 'rgba16float' }, { format: 'rg16float' }];
     this.taaWrite = 0;
     /* A resized target is a new texture, so whatever the history held is gone. */
     this.temporalHistory.invalidate();
@@ -14743,7 +14801,17 @@ export class WebGPURenderer implements RendererApi {
       const scene = this.sceneColorView;
       const history = this.taaViews[i];
       const resolved = this.taaViews[1 - i];
-      if (scene === null || history === null || resolved === null) continue;
+      const record = this.taaRecordViews[i];
+      const motion = this.taaMotionViews[i];
+      if (
+        scene === null ||
+        history === null ||
+        resolved === null ||
+        record === null ||
+        motion === null
+      ) {
+        continue;
+      }
       this.taaBindGroups[i] = device.createBindGroup({
         label: `post.taaBindGroup${i}`,
         layout: this.taaLayout,
@@ -14751,6 +14819,8 @@ export class WebGPURenderer implements RendererApi {
           { binding: TAA_UNIFORMS, resource: { buffer: this.taaUniforms, size: TAA_FRAG_SIZE } },
           ...entry(TAA_TEXTURES.uScene, scene),
           ...entry(TAA_TEXTURES.uHistory, history),
+          ...entry(TAA_TEXTURES.uFlicker, record),
+          ...entry(TAA_TEXTURES.uFlickerMotion, motion),
           ...entry(TAA_TEXTURES.uDepth, this.resolvedDepthView, true),
         ],
       });

package/src/render/flameLight.ts

@@ -82,6 +82,7 @@ export function flameFrequencyHz(diameterM: number): number {
 export function createFlame(options: FlameOptions): Flame {
   const height = HEIGHT_PER_DIAMETER * options.diameterM;
   const centre: Vec3 = [options.x, options.y + height / 3, options.z];
+  const swayM = (options.sway ?? SWAY_PER_HEIGHT) * height;
   /* A seed spread over the whole turn, so seeds 1 and 2 are not neighbours in phase. */
   const phase = ((options.seed ?? 0) * 2.399963) % (Math.PI * 2);
   const light: PointLightSource = {
@@ -94,7 +95,19 @@ export function createFlame(options: FlameOptions): Flame {
     radius: options.radius,
     /* Off, because this helper is the flicker; the selection's own would apply a second one. */
     flicker: 0,
-    shadowNear: Math.max(0.05, options.diameterM),
+    /*
+     * **Clear of what the fire burns from wherever the light has wandered**, which is the sway added
+     * to the near plane a still flame would want. The shadow map is baked from where the light
+     * stood, so the cut moves with it, and each axis moves by at most `swayM`: a near plane of D
+     * alone left a brazier's bowl 7 mm inside it at the top of the sway and 13 cm outside at the
+     * bottom, and the bowl's shadow on the floor under the brazier came and went with every
+     * re-bake — a dark disc on some, none on others.
+     *
+     * What it gives up is `swayM` of shadow nearest the light, which is inside the fixture. What
+     * would make it wrong is a fixture reaching further below the flame than D / 6: this clears
+     * that far and no further, so a deep bowl sets its own `shadowNear` from its own depth.
+     */
+    shadowNear: Math.max(0.05, options.diameterM) + swayM,
     sourceRadius: options.diameterM / 2,
     ...(options.castsShadow === false ? { castsShadow: false } : {}),
   };
@@ -112,7 +125,7 @@ export function createFlame(options: FlameOptions): Flame {
     color: [options.color[0], options.color[1], options.color[2]],
     flicker: options.flicker ?? 0.18,
     phase,
-    swayM: (options.sway ?? SWAY_PER_HEIGHT) * height,
+    swayM,
   };
 }
 

package/src/render/pointShadowBudget.ts

@@ -86,7 +86,8 @@ export function planPointShadowBakes(
 }
 
 /**
- * The shaded lights that also cast, in the order they were shaded.
+ * The shaded lights that also cast, each at its own place in the shaded list, and −1 at the place
+ * of a light that does not.
  *
  * `castsShadow: false` says a light is not worth a cubemap. `selectPointLights` honours
  * that when it builds the *eligible* list, and that was taken for the whole promise — but
@@ -98,7 +99,16 @@ export function planPointShadowBakes(
  * It showed up as a shadow with nothing to throw it — a lamp that rides the camera
  * declines to cast for exactly that reason, and cast anyway.
  *
- * Writes into `out` and returns how many it wrote; allocation-free, because this runs
+ * **The place is kept rather than the gap closed, because the place is the shader's index.** The
+ * pool publishes each map under its light's position in this list, and the shader reads a light's
+ * shadow at the light's position in the shaded one. Closing the gap made the two numberings
+ * disagree after the first light that declined: every lamp shaded after it was published one
+ * place down, the first on the declining light and each of the rest on its neighbour. A consumer
+ * whose headlights decline, and are nearly always shaded first, could only keep its lamps honest by
+ * dropping the shadows of every lamp ranked after them, and which lamps those were changed as the
+ * car moved.
+ *
+ * Writes into `out` and returns how many places it wrote; allocation-free, because this runs
  * every frame.
  */
 export function selectCastingLights(
@@ -107,14 +117,12 @@ export function selectCastingLights(
   activeCount: number,
   out: Int32Array,
 ): number {
-  let written = 0;
-  for (let i = 0; i < activeCount && written < out.length; i++) {
+  const count = Math.min(activeCount, out.length);
+  for (let i = 0; i < count; i++) {
     const worldIndex = activeWorldIndices[i] ?? -1;
-    if (worldIndex < 0) continue;
-    if (lights[worldIndex]?.castsShadow === false) continue;
-    out[written++] = worldIndex;
+    out[i] = worldIndex >= 0 && lights[worldIndex]?.castsShadow !== false ? worldIndex : -1;
   }
-  return written;
+  return count;
 }
 
 /**
@@ -248,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
@@ -277,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;
     /*
@@ -320,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/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;