@driftengine/core 4.4.1 → 4.5.0

package/dist/render/sunGlassTint.js

@@ -0,0 +1,79 @@
+/**
+ * What the sun's light keeps of itself through glass: an RGBA8 array of two layers, static and
+ * moving, beside the sun's depth array. RGB is the product of every pane's
+ * `transmission × (1 − F) × tint`, A the product of their clarities (`glassShadow.ts`).
+ *
+ * **Cleared to white and drawn with a multiplying blend and no depth test**, so every pane on a ray
+ * contributes and the order they come in cannot matter. **Mipmapped and filtered**, unlike the
+ * depths beside it: a frosted pane's colour is read at the level its spread asks for, so a wide
+ * spread is smooth rather than a scatter of taps — the chain is rebuilt after every draw of a layer.
+ * `'half'` makes it half the depth map's size and nothing else changes: the light matrix is the
+ * same, so a texel is a texel of the same place, only larger.
+ */
+export class SunGlassTint {
+    size;
+    texture;
+    framebuffer;
+    constructor(gl, size) {
+        this.size = size;
+        const texture = gl.createTexture();
+        const framebuffer = gl.createFramebuffer();
+        if (texture === null || framebuffer === null) {
+            throw new Error('SunGlassTint: the tint target could not be created');
+        }
+        this.texture = texture;
+        this.framebuffer = framebuffer;
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture);
+        gl.texStorage3D(gl.TEXTURE_2D_ARRAY, mipLevels(size), gl.RGBA8, size, size, 2);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        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);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+        /* Both layers born clear: a layer no pane has reached lets everything through. */
+        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+        for (let layer = 0; layer < 2; layer++) {
+            gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, texture, 0, layer);
+            gl.clearBufferfv(gl.COLOR, 0, CLEAR);
+        }
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        this.fillMips(gl);
+    }
+    /** Bind `layer` (0 static, 1 moving), clear it to white, and set the multiplying state. */
+    begin(gl, layer) {
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, this.texture, 0, layer);
+        gl.viewport(0, 0, this.size, this.size);
+        gl.clearBufferfv(gl.COLOR, 0, CLEAR);
+        gl.disable(gl.DEPTH_TEST);
+        gl.depthMask(false);
+        gl.disable(gl.POLYGON_OFFSET_FILL);
+        gl.enable(gl.BLEND);
+        gl.blendEquation(gl.FUNC_ADD);
+        gl.blendFuncSeparate(gl.DST_COLOR, gl.ZERO, gl.DST_ALPHA, gl.ZERO);
+    }
+    /** Put back what `begin` changed, and rebuild the mip chain the frost reads. */
+    end(gl) {
+        gl.disable(gl.BLEND);
+        gl.depthMask(true);
+        gl.enable(gl.DEPTH_TEST);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        this.fillMips(gl);
+    }
+    /** Every level from level 0, both layers: bound on the active unit and handed back. */
+    fillMips(gl) {
+        const previous = gl.getParameter(gl.TEXTURE_BINDING_2D_ARRAY);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.texture);
+        gl.generateMipmap(gl.TEXTURE_2D_ARRAY);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, previous);
+    }
+    dispose(gl) {
+        gl.deleteFramebuffer(this.framebuffer);
+        gl.deleteTexture(this.texture);
+    }
+}
+const CLEAR = new Float32Array([1, 1, 1, 1]);
+/** A full chain down to one texel. */
+function mipLevels(size) {
+    return Math.floor(Math.log2(Math.max(1, size))) + 1;
+}

package/dist/render/temporalAa.d.ts

@@ -76,6 +76,146 @@ export type Rgb = [number, number, number];
  * spells it this way.
  */
 export declare function clipToNeighbourhood(out: Rgb, history: readonly [number, number, number], min: readonly [number, number, number], max: readonly [number, number, number]): Rgb;
+/**
+ * **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 declare const FLICKER_MEMORY: number;
+/**
+ * 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 declare 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 declare 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 declare 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 declare const FLICKER_SURFACE = 0.02;
+/** Whether a record follows the surface it was kept for: see `FLICKER_SURFACE`. */
+export declare function sameSurface(expected: number, stood: ArrayLike<number>, swing: number): boolean;
+/**
+ * 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 declare function missedBy(expected: number, stood: ArrayLike<number>): number;
+/**
+ * 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 declare function nextDepthSwing(swing: number, missed: number): number;
+/**
+ * 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 declare const STILL_FROM = 0.01;
+export declare 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 declare function freshFlicker(out: Flicker, sample: number): Flicker;
+/** Rec. 709 luma, which is what the record measures in. */
+export declare function luma(c: readonly [number, number, number]): number;
+/** One for a pixel whose reprojection did not move, falling to none at a twentieth of a pixel. */
+export declare function stillness(motionPixels: number): number;
+/**
+ * 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 declare function proven(record: Flicker, sample: number): boolean;
+/** How far a pixel's box widens this frame: by its spread, once proven, and only while still. */
+export declare function flickerWidening(record: Flicker, sample: number, still: number): number;
+/** How much of the history this frame keeps: the base blend, or more once proven. */
+export declare function flickerBlend(base: number, record: Flicker, sample: number, still: number): number;
+/** Whether two periods' means are the same, one to zero. */
+export declare function repeats(mean: number, previous: number): number;
+/**
+ * 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 declare function nextFlicker(out: Flicker, previous: Flicker, sample: number, still: number, periodStart: boolean): Flicker;
 /**
  * Whether the last frame left a picture this one may sample, and where the jitter has got to.
  *
@@ -97,6 +237,11 @@ export declare class TemporalHistory {
      * and not two.
      */
     openFrame(width: number, height: number): boolean;
+    /**
+     * 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;
     /** A resolved picture is now in the history, at the size the frame was opened with. */
     accumulated(): void;
     /** Forget it — a cut, a teleport, or anything else that makes the last frame a different scene. */

package/dist/render/temporalAa.js

@@ -129,6 +129,189 @@ export function clipToNeighbourhood(out, history, min, max) {
     out[2] = centre[2] + offset[2] * scale;
     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, stood, swing) {
+    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, stood) {
+    let nearest = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < stood.length; i++) {
+        const depth = stood[i];
+        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, missed) {
+    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 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, sample) {
+    out.spread = 0;
+    out.sum = sample * FLICKER_MEMORY;
+    out.mean = sample;
+    out.repeated = 0;
+    return out;
+}
+function smoothstep(edge0, edge1, x) {
+    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) {
+    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) {
+    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, sample) {
+    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, sample) {
+    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, sample, still) {
+    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, record, sample, still) {
+    return proven(record, sample) ? base + (FLICKER_BLEND - base) * still : base;
+}
+/** Whether two periods' means are the same, one to zero. */
+export function repeats(mean, previous) {
+    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, previous, sample, still, periodStart) {
+    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.
  *
@@ -158,6 +341,13 @@ export class TemporalHistory {
         this.height = height;
         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() {
+        return this.frameIndex % JITTER_PERIOD === 0;
+    }
     /** A resolved picture is now in the history, at the size the frame was opened with. */
     accumulated() {
         this.picture = true;

package/dist/render/temporalPass.d.ts

@@ -1,16 +1,3 @@
-/**
- * The temporal resolve on WebGL2: this frame blended into where the last one was.
- *
- * **Two targets and a swap, because a pass cannot read the texture it is writing.** The history is
- * sampled at a reprojected coordinate, which is somewhere else in the same image, so reading and
- * writing one texture is a feedback loop — undefined in WebGL2 and in practice whatever the driver
- * left in the cache. So the resolve writes into the one it did not read and the pair swaps, which
- * costs one more full-size texture and nothing per pixel.
- *
- * **What it returns is what the composite must then treat as the scene.** Bloom, occlusion and the
- * grade all read the scene texture, and reading the unresolved one would grade a stable picture
- * from an unstable source and put the crawl back on screen through the bloom.
- */
 export declare class TemporalPass {
     private readonly gl;
     /**
@@ -27,6 +14,21 @@ export declare class TemporalPass {
     private readonly vao;
     /** The pair, and which of them the next resolve writes into. */
     private textures;
+    /**
+     * Each pixel's flicker record, a pair beside the history's and swapped with it: see the
+     * anti-flicker in `temporalAa.ts`. In the history's own format, which holds what the record does —
+     * a change and a sample are colours' luma, and eight bits hold them wherever eight bits hold the
+     * colour.
+     */
+    private records;
+    /** The rest of each pixel's record — depth, pull and recent swing — beside the first. */
+    private motions;
+    /**
+     * Whether the records can be half float, which the depth in them needs. Asked of the context
+     * rather than taken from the scene's format, since a record of an eight-bit scene still holds
+     * metres. Without it the anti-flicker is off and the resolve is the one before it existed.
+     */
+    private readonly recordFloat;
     private framebuffers;
     private write;
     private width;
@@ -49,6 +51,6 @@ export declare class TemporalPass {
      * first frame, the frame after a resize and the frame after a cut pass zero, and the shader
      * then returns this frame before it touches depth or history at all.
      */
-    temporalResolve(scene: WebGLTexture, depth: WebGLTexture, reprojection: Float32Array, width: number, height: number, blend: number): WebGLTexture;
+    temporalResolve(scene: WebGLTexture, depth: WebGLTexture, reprojection: Float32Array, width: number, height: number, blend: number, periodStart: boolean, depthToViewZ: Float32Array): WebGLTexture;
     dispose(): void;
 }

package/dist/render/temporalPass.js

@@ -14,6 +14,8 @@ import { TEMPORAL_RESOLVE_FRAG } from './shaders/temporalResolve.js';
  * grade all read the scene texture, and reading the unresolved one would grade a stable picture
  * from an unstable source and put the crawl back on screen through the bloom.
  */
+/** The resolve's three outputs: the picture and the two halves of the flicker record. */
+const DRAW_ALL = [0x8ce0, 0x8ce1, 0x8ce2]; // COLOR_ATTACHMENT0, 1, 2
 export class TemporalPass {
     gl;
     floatColor;
@@ -22,6 +24,21 @@ export class TemporalPass {
     vao;
     /** The pair, and which of them the next resolve writes into. */
     textures = [null, null];
+    /**
+     * Each pixel's flicker record, a pair beside the history's and swapped with it: see the
+     * anti-flicker in `temporalAa.ts`. In the history's own format, which holds what the record does —
+     * a change and a sample are colours' luma, and eight bits hold them wherever eight bits hold the
+     * colour.
+     */
+    records = [null, null];
+    /** The rest of each pixel's record — depth, pull and recent swing — beside the first. */
+    motions = [null, null];
+    /**
+     * Whether the records can be half float, which the depth in them needs. Asked of the context
+     * rather than taken from the scene's format, since a record of an eight-bit scene still holds
+     * metres. Without it the anti-flicker is off and the resolve is the one before it existed.
+     */
+    recordFloat;
     framebuffers = [null, null];
     write = 0;
     width = 0;
@@ -38,6 +55,7 @@ export class TemporalPass {
     floatColor) {
         this.gl = gl;
         this.floatColor = floatColor;
+        this.recordFloat = gl.getExtension('EXT_color_buffer_float') !== null;
         this.program = compileProgram(gl, FULLSCREEN_VERT, TEMPORAL_RESOLVE_FRAG, 'temporalResolve');
         this.uniforms = uniformLocations(gl, this.program, 'temporalPass');
         const vao = gl.createVertexArray();
@@ -54,24 +72,36 @@ export class TemporalPass {
         for (let i = 0; i < 2; i++) {
             if (this.textures[i] === null)
                 this.textures[i] = gl.createTexture();
-            gl.bindTexture(gl.TEXTURE_2D, this.textures[i]);
-            if (this.floatColor) {
-                gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, width, height, 0, gl.RGBA, gl.HALF_FLOAT, null);
-            }
-            else {
-                gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+            if (this.records[i] === null)
+                this.records[i] = gl.createTexture();
+            if (this.motions[i] === null)
+                this.motions[i] = gl.createTexture();
+            for (const texture of [this.textures[i], this.records[i], this.motions[i]]) {
+                gl.bindTexture(gl.TEXTURE_2D, texture);
+                if (texture === this.textures[i] ? this.floatColor : this.recordFloat) {
+                    /* The depth record is two numbers a pixel: metres, and how far they swing. */
+                    const pair = texture === this.motions[i];
+                    gl.texImage2D(gl.TEXTURE_2D, 0, pair ? gl.RG16F : gl.RGBA16F, width, height, 0, pair ? gl.RG : gl.RGBA, gl.HALF_FLOAT, null);
+                }
+                else {
+                    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+                }
+                /* Linear, because the history is sampled between texels wherever the reprojection lands;
+                   clamped, because a sample that wrapped would pull the far edge of the screen into the
+                   corner — and the shader rejects an off-screen reprojection before it can anyway. */
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+                gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
             }
-            /* Linear, because the history is sampled between texels wherever the reprojection lands;
-               clamped, because a sample that wrapped would pull the far edge of the screen into the
-               corner — and the shader rejects an off-screen reprojection before it can anyway. */
-            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
             if (this.framebuffers[i] === null)
                 this.framebuffers[i] = gl.createFramebuffer();
             gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffers[i]);
             gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.textures[i], 0);
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this.records[i], 0);
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, gl.TEXTURE_2D, this.motions[i], 0);
+            /* Per framebuffer, so set once here: the resolve writes the picture and the record. */
+            gl.drawBuffers(DRAW_ALL);
         }
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
     }
@@ -82,7 +112,7 @@ export class TemporalPass {
      * first frame, the frame after a resize and the frame after a cut pass zero, and the shader
      * then returns this frame before it touches depth or history at all.
      */
-    temporalResolve(scene, depth, reprojection, width, height, blend) {
+    temporalResolve(scene, depth, reprojection, width, height, blend, periodStart, depthToViewZ) {
         const { gl } = this;
         this.ensureSize(width, height);
         const target = this.write;
@@ -103,9 +133,18 @@ export class TemporalPass {
         gl.activeTexture(gl.TEXTURE2);
         gl.bindTexture(gl.TEXTURE_2D, depth);
         gl.uniform1i(this.uniforms['uDepth'] ?? null, 2);
+        gl.activeTexture(gl.TEXTURE3);
+        gl.bindTexture(gl.TEXTURE_2D, this.records[history]);
+        gl.uniform1i(this.uniforms['uFlicker'] ?? null, 3);
+        gl.activeTexture(gl.TEXTURE4);
+        gl.bindTexture(gl.TEXTURE_2D, this.motions[history]);
+        gl.uniform1i(this.uniforms['uFlickerMotion'] ?? null, 4);
+        gl.uniform4fv(this.uniforms['uDepthToViewZ'] ?? null, depthToViewZ);
+        gl.uniform1f(this.uniforms['uAntiFlicker'] ?? null, this.recordFloat ? 1 : 0);
         gl.uniformMatrix4fv(this.uniforms['uReprojection'] ?? null, false, reprojection);
         gl.uniform2f(this.uniforms['uTexel'] ?? null, 1 / width, 1 / height);
         gl.uniform1f(this.uniforms['uHistoryBlend'] ?? null, blend);
+        gl.uniform1f(this.uniforms['uPeriodStart'] ?? null, periodStart ? 1 : 0);
         gl.bindVertexArray(this.vao);
         gl.drawArrays(gl.TRIANGLES, 0, 3);
         gl.bindVertexArray(null);
@@ -122,9 +161,15 @@ export class TemporalPass {
         for (let i = 0; i < 2; i++) {
             if (this.textures[i] !== null)
                 gl.deleteTexture(this.textures[i]);
+            if (this.records[i] !== null)
+                gl.deleteTexture(this.records[i]);
+            if (this.motions[i] !== null)
+                gl.deleteTexture(this.motions[i]);
             if (this.framebuffers[i] !== null)
                 gl.deleteFramebuffer(this.framebuffers[i]);
             this.textures[i] = null;
+            this.records[i] = null;
+            this.motions[i] = null;
             this.framebuffers[i] = null;
         }
         gl.deleteProgram(this.program);

package/dist/render/translucentQueue.d.ts

@@ -1,5 +1,6 @@
 import type { ReadonlyMat4 } from 'gl-matrix';
 import type { TranslucentMeshOptions } from './backend/webgl2/renderer.ts';
+import type { ResolvedGlass } from './glass.ts';
 /**
  * The frame's translucent draws, held so they can be submitted more than once.
  *
@@ -46,11 +47,14 @@ export interface TranslucentDraw {
     /** What survives one metre of the medium. Null where the draw named none; otherwise a copy. */
     refractTint: Float32Array | null;
     thicknessM: number;
+    /** Glass, resolved, or null for a draw that is not glass. See `glass.ts`. */
+    glass: ResolvedGlass | null;
 }
 export declare class TranslucentQueue {
     private readonly pool;
     private count;
     private refracting;
+    private glassing;
     /** How many draws this frame has recorded. */
     get length(): number;
     /**
@@ -58,6 +62,8 @@ export declare class TranslucentQueue {
      * frame behind it first, and does not copy it for a set that never reads it.
      */
     get refracts(): boolean;
+    /** Whether anything recorded this frame is glass, so the copy it reads needs its mip chain. */
+    get glassy(): boolean;
     /** How many records are pooled, which a test uses to assert a steady scene stops allocating. */
     get capacity(): number;
     /**