@driftengine/core 4.4.1 → 4.4.2

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

@@ -39,6 +39,7 @@
  * and the uniform `recon: ReconParams`, whose struct this module declares.
  */
 import { wgslSceneDepthToNdc } from '../../depthConvention.ts';
+import { PLANAR_FROM, PLANAR_TO } from '../../recon/disocclusion.ts';
 
 /**
  * The parameters one resolve reads, as `ResolveFrame` minus its images.
@@ -97,6 +98,8 @@ export const RECON_HISTORY_FORMAT: GPUTextureFormat = 'rgba16float';
 export const RECON_RESOLVE_CORE_WGSL = /* wgsl */ `
 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};
 
 fn reconClampTexel(value: i32, size: i32) -> i32 {
   return clamp(value, 0, size - 1);
@@ -328,10 +331,11 @@ fn reconDisocclusion(
   histDepth: f32,
   motionLength: f32,
   normalDot: f32,
+  slope: f32,
 ) -> f32 {
   if (!(currDepth > 0.0) || !(histDepth > 0.0) || !(motionLength >= 0.0)) { return 0.0; }
   let disagreement = abs(currDepth - histDepth) / currDepth;
-  let tolerance = recon.depthTolerance + recon.motionScale * motionLength;
+  let tolerance = recon.depthTolerance + recon.motionScale * motionLength + slope;
   let depth = 1.0 - reconSmoothstep(tolerance, 2.0 * tolerance, disagreement);
   let normal = reconSmoothstep(recon.normalFloor, recon.normalCeiling, normalDot);
   return depth * normal;
@@ -392,6 +396,74 @@ fn reconNormalAt(previous: bool, x: i32, y: i32) -> ReconNormal {
   return reconNormalFrom(centre.position, right.position, up.position, eye);
 }
 
+/* resolve.ts's viewDepthAt. */
+fn reconViewDepthAt(previous: bool, x: i32, y: i32) -> f32 {
+  let w = i32(recon.renderSize.x);
+  let h = i32(recon.renderSize.y);
+  if (x < 0 || y < 0 || x >= w || y >= h) { return 0.0; }
+  var jitter = recon.jitter;
+  var m = recon.inverseViewProj;
+  var z = 0.0;
+  if (previous) {
+    jitter = recon.previousJitter;
+    m = recon.previousInverseViewProj;
+    z = reconPreviousDepth(x, y);
+  } else {
+    z = reconDepth(x, y);
+  }
+  let u = (f32(x) + 0.5 - jitter.x) / f32(w);
+  let v = (f32(y) + 0.5 - jitter.y) / f32(h);
+  let cw = m[0][3] * (u * 2.0 - 1.0) + m[1][3] * (v * 2.0 - 1.0) + m[2][3] * z + m[3][3];
+  if (!(abs(cw) > 1e-12)) { return 0.0; }
+  return 1.0 / cw;
+}
+
+/* disocclusion.ts's planarity. */
+fn reconPlanarity(before: f32, centre: f32, after: f32) -> f32 {
+  if (!(before > 0.0) || !(centre > 0.0) || !(after > 0.0)) { return 1.0; }
+  let a = 1.0 / after - 1.0 / centre;
+  let b = 1.0 / before - 1.0 / centre;
+  let spread = abs(a) + abs(b);
+  if (!(spread > 0.0)) { return 1.0; }
+  return 1.0 - reconSmoothstep(RECON_PLANAR_FROM, RECON_PLANAR_TO, abs(a + b) / spread);
+}
+
+/* disocclusion.ts's surfaceSlope. */
+fn reconSurfaceSlope(before: f32, centre: f32, after: f32) -> f32 {
+  let hasAfter = after > 0.0;
+  let hasBefore = before > 0.0;
+  if (!hasAfter) {
+    if (!hasBefore) { return 0.0; }
+    return abs(before - centre) / centre;
+  }
+  if (!hasBefore) { return abs(after - centre) / centre; }
+  let a = after - centre;
+  let b = before - centre;
+  if (a * b > 0.0) { return 0.0; }
+  return min(abs(a), abs(b)) / centre;
+}
+
+struct ReconSurface {
+  planar: f32,
+  slope: f32,
+}
+
+/* resolve.ts's surfaceAt. */
+fn reconSurfaceAt(previous: bool, x: i32, y: i32, centre: f32) -> ReconSurface {
+  var out: ReconSurface;
+  out.planar = 1.0;
+  out.slope = 0.0;
+  for (var axis = 0; axis < 2; axis = axis + 1) {
+    let ax = 1 - axis;
+    let ay = axis;
+    let after = reconViewDepthAt(previous, x + ax, y + ay);
+    let before = reconViewDepthAt(previous, x - ax, y - ay);
+    out.planar = out.planar * reconPlanarity(before, centre, after);
+    out.slope = max(out.slope, reconSurfaceSlope(before, centre, after));
+  }
+  return out;
+}
+
 struct ReconHistory {
   weight: f32,
   colour: vec4<f32>,
@@ -439,14 +511,46 @@ fn reconHistoryWeight(u: f32, v: f32, dx: i32, dy: i32) -> ReconHistory {
     pu * f32(recon.outputSize.x) - 0.5,
     pv * f32(recon.outputSize.y) - 0.5,
   );
-  let px = reconClampTexel(i32(reconRound(pu * rw + recon.previousJitter.x - 0.5)), i32(rw));
-  let py = reconClampTexel(i32(reconRound(pv * rh + recon.previousJitter.y - 0.5)), i32(rh));
-  let held = reconWorldAt(true, px, py).depth;
+  /* Last frame's depth, searched around where the dilated texel was: see resolve.ts. */
+  let su = (f32(dx) + 0.5 - recon.jitter.x) / rw + mu;
+  let sv = (f32(dy) + 0.5 - recon.jitter.y) / rh + mv;
+  let cx = reconClampTexel(i32(reconRound(su * rw + recon.previousJitter.x - 0.5)), i32(rw));
+  let cy = reconClampTexel(i32(reconRound(sv * rh + recon.previousJitter.y - 0.5)), i32(rh));
+  var held = reconViewDepthAt(true, cx, cy);
+  var px = cx;
+  var py = cy;
+  if (!(held > 0.0 && abs(held - expected) <= recon.depthTolerance * expected)) {
+    held = 0.0;
+    var nearest = 3.4e38;
+    for (var j = -1; j <= 1; j = j + 1) {
+      for (var i = -1; i <= 1; i = i + 1) {
+        let tx = reconClampTexel(cx + i, i32(rw));
+        let ty = reconClampTexel(cy + j, i32(rh));
+        let depth = reconViewDepthAt(true, tx, ty);
+        if (!(depth > 0.0)) { continue; }
+        let off = abs(depth - expected);
+        if (off < nearest) {
+          nearest = off;
+          held = depth;
+          px = tx;
+          py = ty;
+        }
+      }
+    }
+  }
+
+  let here = reconSurfaceAt(false, dx, dy, reconViewDepthAt(false, dx, dy));
+  var planar = here.planar;
+  if (planar > 0.0) { planar = planar * reconSurfaceAt(true, px, py, held).planar; }
   var normalDot = 1.0;
-  let here = reconNormalAt(false, dx, dy);
-  let there = reconNormalAt(true, px, py);
-  if (here.ok && there.ok) { normalDot = dot(here.normal, there.normal); }
-  let trust = reconDisocclusion(expected, held, length(vec2<f32>(mu, mv)), normalDot);
+  if (planar > 0.0) {
+    let hereNormal = reconNormalAt(false, dx, dy);
+    let thereNormal = reconNormalAt(true, px, py);
+    if (hereNormal.ok && thereNormal.ok) {
+      normalDot = 1.0 - planar * (1.0 - dot(hereNormal.normal, thereNormal.normal));
+    }
+  }
+  let trust = reconDisocclusion(expected, held, length(vec2<f32>(mu, mv)), normalDot, here.slope);
   out.weight = out.colour.w * trust;
   return out;
 }

package/src/render/shaders/temporalResolve.ts

@@ -20,6 +20,15 @@
  * The vertex stage is `FULLSCREEN_VERT`, shared with the occlusion pass, its blur and the rush.
  */
 import { glslSceneDepthToNdc } from '../depthConvention.ts';
+import {
+  FLICKER_BLEND,
+  FLICKER_MEMORY,
+  FLICKER_REPEAT,
+  FLICKER_SURFACE,
+  FLICKER_WIDTH,
+  STILL_FROM,
+  STILL_TO,
+} from '../temporalAa.ts';
 
 export const TEMPORAL_RESOLVE_FRAG = `#version 300 es
 precision highp float;
@@ -30,6 +39,22 @@ in vec2 vUv;
 uniform sampler2D uScene;
 /** What this pass wrote last frame: resolved, and conceptually unjittered. */
 uniform sampler2D uHistory;
+/**
+ * Each pixel's flicker record from last frame, the anti-flicker in temporalAa.ts: its spread about
+ * its period's mean, the sum this period has gathered, the last period's mean, and how many periods
+ * running have repeated. highp for the reason the depth's is: a luma in a half-float scene is not a
+ * value from 0 to 1.
+ */
+uniform highp sampler2D uFlicker;
+/**
+ * The rest of the record: the view depth the pixel's sample stood at, so the next frame can tell
+ * whether it follows the same surface, and the pixel's own depth swing, which that test allows for.
+ */
+uniform highp sampler2D uFlickerMotion;
+/** The inverse projection's depth row and w row, as the other passes read a depth into metres. */
+uniform vec4 uDepthToViewZ;
+/** One where the records can hold what they hold, zero where they cannot: then 4.4.1's resolve. */
+uniform float uAntiFlicker;
 /**
  * The frame's depth.
  *
@@ -53,6 +78,8 @@ uniform highp sampler2D uDepth;
 uniform mat4 uReprojection;
 /** One texel of the target, for walking the neighbourhood. */
 uniform vec2 uTexel;
+/** One on the first frame of the jitter's period, where the anti-flicker compares two periods. */
+uniform float uPeriodStart;
 /**
  * How much of the clipped history to keep, 0 to 1.
  *
@@ -63,7 +90,41 @@ uniform vec2 uTexel;
  */
 uniform float uHistoryBlend;
 
-out vec4 fragColor;
+layout(location = 0) out vec4 fragColor;
+/** The record carried out, in the texture uFlicker reads next frame. */
+layout(location = 1) out vec4 flickerOut;
+/** And the rest of it, in the texture uFlickerMotion reads. */
+layout(location = 2) out vec4 flickerMotionOut;
+
+const float FLICKER_MEMORY = ${FLICKER_MEMORY.toFixed(3)};
+const float FLICKER_WIDTH = ${FLICKER_WIDTH.toFixed(1)};
+const float FLICKER_REPEAT = ${FLICKER_REPEAT.toFixed(2)};
+const float FLICKER_BLEND = ${FLICKER_BLEND.toFixed(2)};
+const float FLICKER_SURFACE = ${FLICKER_SURFACE.toFixed(2)};
+const float STILL_FROM = ${STILL_FROM.toFixed(2)};
+const float STILL_TO = ${STILL_TO.toFixed(2)};
+
+float luma(vec3 c) {
+  return dot(c, vec3(0.2126, 0.7152, 0.0722));
+}
+
+/** A record starting over: no spread, and nothing repeated yet. */
+vec4 freshRecord(vec3 current) {
+  float seen = luma(current);
+  return vec4(0.0, seen * FLICKER_MEMORY, seen, 0.0);
+}
+
+/** Metres in front of the camera, from a depth sample, as depthOfField.ts reads one. */
+float viewDepthOf(float depth) {
+  float z = ${glslSceneDepthToNdc('depth')};
+  return -(uDepthToViewZ.x * z + uDepthToViewZ.y) / (uDepthToViewZ.z * z + uDepthToViewZ.w);
+}
+
+/** Whether two periods' means are the same, one to zero. */
+float repeats(float mean, float previous) {
+  float apart = abs(mean - previous) / max(max(mean, previous), 1.0 / 255.0);
+  return 1.0 - smoothstep(FLICKER_REPEAT, 2.0 * FLICKER_REPEAT, apart);
+}
 
 /**
  * The colours actually present around this pixel this frame, as a box.
@@ -155,19 +216,45 @@ void main() {
   /* Nothing to blend towards: the first frame, a resize, a cut, or the effect switched off. */
   if (uHistoryBlend <= 0.0) {
     fragColor = vec4(current, 1.0);
+    flickerOut = freshRecord(current);
+    flickerMotionOut = vec4(0.0);
     return;
   }
 
+  /*
+   * **The motion is the nearest surface's among the nine**, the dilation every temporal resolve
+   * uses: a pixel at a thin thing samples it in some frames and what is behind it in others, and the
+   * two move apart as the camera does, so reprojecting each frame by whichever it caught sends its
+   * history and its record somewhere different every frame. A crack of light round a door moves with
+   * the door that frames it, and so does its pixel. The depth kept is that surface's too, so the record
+   * keeps and next frame tests the depth the reprojection followed.
+   */
+  vec2 nearestAt = vUv;
   float depth = textureLod(uDepth, vUv, 0.0).r;
-  vec4 clip = vec4(vUv * 2.0 - 1.0, ${glslSceneDepthToNdc('depth')}, 1.0);
+  float metres = viewDepthOf(depth);
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 at = vUv + vec2(float(x), float(y)) * uTexel;
+      float tap = textureLod(uDepth, at, 0.0).r;
+      float tapMetres = viewDepthOf(tap);
+      if (tapMetres < metres) {
+        metres = tapMetres;
+        depth = tap;
+        nearestAt = at;
+      }
+    }
+  }
+  vec4 clip = vec4(nearestAt * 2.0 - 1.0, ${glslSceneDepthToNdc('depth')}, 1.0);
   vec4 previous = uReprojection * clip;
   /* Behind the previous eye: there is no last-frame position to sample. */
   if (previous.w <= 0.0) {
     fragColor = vec4(current, 1.0);
+    flickerOut = freshRecord(current);
+    flickerMotionOut = vec4(metres, 0.0, 0.0, 0.0);
     return;
   }
 
-  vec2 wasUv = (previous.xy / previous.w) * 0.5 + 0.5;
+  vec2 wasUv = vUv + ((previous.xy / previous.w) * 0.5 + 0.5 - nearestAt);
   /*
    * **Off the edge of the last frame is a disocclusion**, and the honest answer is this frame's
    * colour rather than a clamped sample of the border, which would drag one row of pixels inward
@@ -175,6 +262,8 @@ void main() {
    */
   if (wasUv.x < 0.0 || wasUv.x > 1.0 || wasUv.y < 0.0 || wasUv.y > 1.0) {
     fragColor = vec4(current, 1.0);
+    flickerOut = freshRecord(current);
+    flickerMotionOut = vec4(metres, 0.0, 0.0, 0.0);
     return;
   }
 
@@ -182,8 +271,55 @@ void main() {
   vec3 hi;
   neighbourhood(lo, hi);
   vec3 history = historyCatmullRom(wasUv);
-  vec3 bounded = clipToNeighbourhood(history, lo, hi);
 
-  fragColor = vec4(mix(current, bounded, uHistoryBlend), 1.0);
+  /*
+   * The anti-flicker, operation for operation the one in temporalAa.ts. The record is read at the
+   * texel where the surface was rather than filtered, so two surfaces' records never mix at an
+   * edge; it is the surface's own if last frame's depth there, or at one of the texels beside it,
+   * is the depth this surface should have had — the nearest of five, because this frame's sample
+   * and last frame's can straddle an edge with nothing moved. Otherwise it is no record.
+   */
+  ivec2 size = textureSize(uFlicker, 0);
+  ivec2 was = clamp(ivec2(wasUv * vec2(size)), ivec2(0), size - 1);
+  float nearest = 1e9;
+  for (int n = 0; n < 5; n++) {
+    ivec2 at = was + (n == 1 ? ivec2(1, 0) : n == 2 ? ivec2(-1, 0) : n == 3 ? ivec2(0, 1) : n == 4 ? ivec2(0, -1) : ivec2(0));
+    float stood = texelFetch(uFlickerMotion, clamp(at, ivec2(0), size - 1), 0).r;
+    if (stood > 0.0) nearest = min(nearest, abs(stood - previous.w));
+  }
+  /* The swing is the pixel's whatever the test says: resetting it would stop it learning one. */
+  vec4 motionThere = texelFetch(uFlickerMotion, was, 0);
+  bool missedAll = nearest > 1e8;
+  bool same = uAntiFlicker > 0.5 && !missedAll &&
+    nearest <= FLICKER_WIDTH * motionThere.g + FLICKER_SURFACE * previous.w;
+  float swingOut = missedAll ? 0.0 : motionThere.g + (nearest - motionThere.g) * FLICKER_MEMORY;
+  float seen = luma(current);
+  vec4 held = same ? texelFetch(uFlicker, was, 0) : freshRecord(current);
+
+  float still = 1.0 - smoothstep(STILL_FROM, STILL_TO, length((wasUv - vUv) / uTexel));
+  float apart = abs(seen - held.b);
+  float reach = FLICKER_WIDTH * held.r + 1.0 / 255.0;
+  bool within = apart <= reach;
+  bool proven = held.a > 0.75 && within;
+  float widen = proven ? FLICKER_WIDTH * held.r * still : 0.0;
+  float blend = proven ? mix(uHistoryBlend, FLICKER_BLEND, still) : uHistoryBlend;
+  vec3 bounded = clipToNeighbourhood(history, lo - widen, hi + widen);
+
+  float sum = held.g;
+  float mean = held.b;
+  float repeated = within ? held.a : 0.0;
+  if (uPeriodStart > 0.5) {
+    repeated = repeats(sum, mean) > 0.5 ? min(1.0, repeated + 0.5) : 0.0;
+    mean = sum;
+    sum = 0.0;
+  }
+  flickerOut = vec4(
+    held.r + (apart - held.r) * FLICKER_MEMORY,
+    sum + seen * FLICKER_MEMORY,
+    mean,
+    repeated * still
+  );
+  flickerMotionOut = vec4(metres, swingOut, 0.0, 0.0);
+  fragColor = vec4(mix(current, bounded, blend), 1.0);
 }
 `;

package/src/render/temporalAa.ts

@@ -154,6 +154,225 @@ export function clipToNeighbourhood(
   return out;
 }
 
+/**
+ * **The anti-flicker: a still pixel's neighbourhood widened by its own flicker.**
+ *
+ * A thread, a crack of light round a door, a leaf finer than a pixel: the jitter catches it in some
+ * phases and misses it in others, and in a phase that misses it the nine taps round a pixel can all
+ * miss it at once. The box collapses onto the background, the history — which had settled on the
+ * thread's share of the pixel — is clipped out, and it grows back a tenth a frame until the next
+ * miss. That is a paused frame flashing at every fine edge, and the clip is doing its job: nothing
+ * in one frame says the thread is still there.
+ *
+ * What does say so is the pixel's own record. **A still camera over a still scene samples every pixel
+ * the same way every period of the jitter, exactly**, so aliasing repeats itself; a surface that moves
+ * across the pixel, a flame, a light that shimmers, does not. So each pixel keeps the mean of its
+ * samples over the last period, the sum it is gathering for this one, how many periods running have
+ * repeated, and the running mean of how far its samples land from their period's mean — and its box
+ * widens by that spread only once two periods running have repeated. Measured on the samples rather
+ * than against the history, because the history is what the clip cuts. **And a sample farther from
+ * its period's mean than the box would widen to is not the flicker the pixel has shown**: something
+ * has arrived, and the count starts again on that frame rather than at the end of the period. **Two, and a mean rather than
+ * one sample**, because one sample repeats by coincidence: stripes sliding across a pixel land on the
+ * same colour at two period starts about as often as not.
+ *
+ * **What it gives up.** A surface arriving over a pixel that was flickering is held back until the
+ * period ends and fails to repeat — at most eight frames, fading a tenth a frame meanwhile; a still
+ * pixel needs three periods before it is helped at all; and a pixel that flickers in a scene that is
+ * itself moving is not helped, since nothing repeats there. Nothing moving past a twentieth of a
+ * pixel a frame is touched, since the reprojection is then what decides.
+ *
+ * **A moving camera had a weaker proof of its own, and it was taken out.** It widened a pixel's box
+ * while its samples swung both ways about their mean, with the record carried through the
+ * reprojection. Measured on a moving courtyard it removed a twentieth of what flickered, and it broke
+ * a sun's shadow line on the floor into dashes that were not there before: the record is read at the
+ * nearest texel, so under sub-pixel motion one pixel widened and its neighbour did not. The resolve
+ * already removes nineteen twentieths of a moving frame's flicker without it. **What would make it wrong** is a jitter
+ * whose sequence does not repeat, where no period is the same twice however still the scene is.
+ */
+
+/** This frame's share of the running spread, and of a period's mean: one period of the jitter. */
+export const FLICKER_MEMORY = 1 / JITTER_PERIOD;
+
+/**
+ * How many spreads a flickering pixel's box widens by. The hardest thread is one missed in a single
+ * phase of eight: that miss needs the box to reach 7/8 of its contrast, and the running spread,
+ * worn down by seven catches that each land an eighth of the contrast from the period's mean, has
+ * fallen to a = 1/8 + (7/8 a + 7/64 − 1/8)·(7/8)⁷ of the contrast by then — 0.181, a steady state
+ * solved by hand — against the 7/32 it averages. Seven eighths over that is 4.8; six leaves room.
+ * Threads caught in a share nearer a half spread more and need fewer.
+ */
+export const FLICKER_WIDTH = 6;
+
+/**
+ * How far apart two periods' means may be, relative to the larger, and still repeat: fully below
+ * this, not at all at twice it. Above an eight-bit record's rounding and a lamp's slow breathing; far
+ * below what anything crossing the pixel does to it.
+ */
+export const FLICKER_REPEAT = 0.05;
+
+/**
+ * How much of the history a pixel proven to repeat keeps, where an unproven one keeps
+ * `TEMPORAL_HISTORY_BLEND`. A settled thread still breathes with the jitter by the share of each
+ * frame's sample that goes into what is shown — a tenth of its contrast at the base blend — and a
+ * pixel that has repeated for two periods has nothing to respond to, so it keeps more: three
+ * hundredths of each frame instead of a tenth. What it costs is a surface arriving inside the
+ * pixel's own swing, which fades in at that rate until the period's check lets it through.
+ */
+export const FLICKER_BLEND = 0.97;
+
+/**
+ * How far last frame's depth may be from the depth a surface should have had there, relative, and
+ * still be that surface: two percent beyond the pixel's own depth swing, taken as the nearest of the
+ * texel where it stood and the four beside it. **The nearest of five and not the one**, because this
+ * frame's sample and last frame's can straddle an edge with nothing moved — the lesson
+ * `recon/resolve.ts` learned the expensive way.
+ *
+ * **And beyond its own swing, because depth aliases the way colour does.** A crack of light round a
+ * door is a pixel whose sample lands on the door in some phases and on what is behind it in others,
+ * so its depth jumps metres with nothing moved, and a test held to two percent reset the record of
+ * exactly the pixels the anti-flicker is for: a held frame went from 5 flickering pixels back to 774.
+ * So each pixel keeps the running mean of how far last frame's depth missed — kept whatever the test
+ * says, since resetting it would stop it ever learning the swing — and the test allows
+ * `FLICKER_WIDTH` of those, as the box does of the colour's. A flat surface's swing is none and its
+ * test stays tight; a surface revealed by the camera is a jump nothing in the pixel's past explains.
+ */
+export const FLICKER_SURFACE = 0.02;
+
+/** Whether a record follows the surface it was kept for: see `FLICKER_SURFACE`. */
+export function sameSurface(expected: number, stood: ArrayLike<number>, swing: number): boolean {
+  return missedBy(expected, stood) <= FLICKER_WIDTH * swing + FLICKER_SURFACE * expected;
+}
+
+/**
+ * How far the nearest of last frame's depths missed the one expected. A depth of nought is a texel
+ * with nothing recorded — the frame after a cut — and is no texel; with none, nothing is missed by
+ * any amount.
+ */
+export function missedBy(expected: number, stood: ArrayLike<number>): number {
+  let nearest = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < stood.length; i++) {
+    const depth = stood[i] as number;
+    if (depth > 0) nearest = Math.min(nearest, Math.abs(depth - expected));
+  }
+  return nearest;
+}
+
+/**
+ * The pixel's depth swing carried on: the running mean of `missedBy`, over a period, and none where
+ * there was nothing to miss — a swing learned from a cut would loosen the test for a whole period.
+ */
+export function nextDepthSwing(swing: number, missed: number): number {
+  return Number.isFinite(missed) ? swing + (missed - swing) * FLICKER_MEMORY : 0;
+}
+
+/**
+ * Reprojected motion in pixels a frame: still below the first, moving from the second. **Small,
+ * because repetition breaks long before motion is visible**: a camera drifting a fifth of a pixel a
+ * frame shifts the grid more than a pixel a period, so nothing repeats, and a ramp to half a pixel
+ * counted that as mostly still and kept vouching for samples that had stopped repeating.
+ */
+export const STILL_FROM = 0.01;
+export const STILL_TO = 0.05;
+
+/**
+ * A pixel's flicker record, in luma: the running spread of its samples about their period's mean,
+ * the sum this period has gathered so far, the last period's mean, and how many periods running have
+ * repeated — none, one or two, as 0, 0.5 and 1.
+ */
+export interface Flicker {
+  spread: number;
+  sum: number;
+  mean: number;
+  repeated: number;
+}
+
+/**
+ * A fresh record for a surface first seen this frame: no spread and nothing repeated. **A
+ * record of another surface is no record**, so the resolve starts one over wherever last frame's
+ * depth says the surface is not the one it followed, before this frame widens by anything.
+ */
+export function freshFlicker(out: Flicker, sample: number): Flicker {
+  out.spread = 0;
+  out.sum = sample * FLICKER_MEMORY;
+  out.mean = sample;
+  out.repeated = 0;
+  return out;
+}
+
+function smoothstep(edge0: number, edge1: number, x: number): number {
+  const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+}
+
+/** Rec. 709 luma, which is what the record measures in. */
+export function luma(c: readonly [number, number, number]): number {
+  return c[0] * 0.2126 + c[1] * 0.7152 + c[2] * 0.0722;
+}
+
+/** One for a pixel whose reprojection did not move, falling to none at a twentieth of a pixel. */
+export function stillness(motionPixels: number): number {
+  return 1 - smoothstep(STILL_FROM, STILL_TO, motionPixels);
+}
+
+/**
+ * Whether a pixel is proven to repeat this frame: two periods running have, and this frame's sample
+ * lands within the reach of the box it would widen to. A sample beyond that reach is something
+ * arriving, and it disqualifies the frame it lands in as well as the count it carries out.
+ */
+export function proven(record: Flicker, sample: number): boolean {
+  return record.repeated > 0.75 && within(record, sample);
+}
+
+/** Whether this frame's sample lands inside the reach of the box the record would widen to. */
+function within(record: Flicker, sample: number): boolean {
+  return Math.abs(sample - record.mean) <= FLICKER_WIDTH * record.spread + 1 / 255;
+}
+
+/** How far a pixel's box widens this frame: by its spread, once proven, and only while still. */
+export function flickerWidening(record: Flicker, sample: number, still: number): number {
+  return proven(record, sample) ? FLICKER_WIDTH * record.spread * still : 0;
+}
+
+/** How much of the history this frame keeps: the base blend, or more once proven. */
+export function flickerBlend(base: number, record: Flicker, sample: number, still: number): number {
+  return proven(record, sample) ? base + (FLICKER_BLEND - base) * still : base;
+}
+
+/** Whether two periods' means are the same, one to zero. */
+export function repeats(mean: number, previous: number): number {
+  const apart = Math.abs(mean - previous) / Math.max(mean, previous, 1 / 255);
+  return 1 - smoothstep(FLICKER_REPEAT, 2 * FLICKER_REPEAT, apart);
+}
+
+/**
+ * The record carried out, from the one carried in and this frame's sample in luma. `periodStart`
+ * is the first frame of the jitter's period, where the period just gathered is compared with the
+ * one before. Forgotten in proportion to motion — a moving pixel's record would be a record of
+ * somewhere else.
+ */
+export function nextFlicker(
+  out: Flicker,
+  previous: Flicker,
+  sample: number,
+  still: number,
+  periodStart: boolean,
+): Flicker {
+  const apart = Math.abs(sample - previous.mean);
+  let { sum, mean, repeated } = previous;
+  if (apart > FLICKER_WIDTH * previous.spread + 1 / 255) repeated = 0;
+  if (periodStart) {
+    repeated = repeats(sum, mean) > 0.5 ? Math.min(1, repeated + 0.5) : 0;
+    mean = sum;
+    sum = 0;
+  }
+  out.spread = previous.spread + (apart - previous.spread) * FLICKER_MEMORY;
+  out.sum = sum + sample * FLICKER_MEMORY;
+  out.mean = mean;
+  out.repeated = repeated * still;
+  return out;
+}
+
 /**
  * Whether the last frame left a picture this one may sample, and where the jitter has got to.
  *
@@ -185,6 +404,14 @@ export class TemporalHistory {
     return usable;
   }
 
+  /**
+   * Whether this frame samples the first phase of the jitter's period, where the anti-flicker
+   * compares the period just gathered with the one before. One answer for both backends.
+   */
+  get periodStart(): boolean {
+    return this.frameIndex % JITTER_PERIOD === 0;
+  }
+
   /** A resolved picture is now in the history, at the size the frame was opened with. */
   accumulated(): void {
     this.picture = true;