@driftengine/core 4.4.2 → 4.6.0

package/dist/render/recon/resolve.js

@@ -30,6 +30,29 @@
  *    the render read bicubically fills the gap. The history keeps colour and weight; the picture shown
  *    is it sharpened.
  *
+ * **And the temporal resolve's anti-flicker, where the caller carries its records** (`temporalAa.ts`
+ * says why it works and what it gives up). A thread finer than a render texel is caught in some
+ * phases of the jitter and missed in others, and in a phase that misses it the nine texels can all
+ * miss it: the box collapses onto what is behind, the history is clipped out, and a still picture
+ * flashes at every fine edge each period. A still camera over a still scene gathers every pixel the
+ * same way each period, so each pixel keeps a record of this frame's gathered luma over the period,
+ * and once two periods running have repeated its box widens by its own spread and it keeps more of
+ * its history. **The record stays at the pixel rather than following the reprojection**, because the
+ * proof is only ever for a pixel that has not moved; it starts over wherever the history did not
+ * survive, and is forgotten in proportion to motion.
+ *
+ * **And a still pixel whose depth has been seen to swing is not a disocclusion.** A rail finer than
+ * a texel in front of a wall is caught in some phases and missed in others, so last frame can hold
+ * the wall where this frame holds the rail with nothing moved — and the depth test threw the history
+ * away, leaving the record nothing to keep. So each pixel also keeps the largest relative miss of
+ * last frame's depth it has seen lately, kept whatever the test says, and while still its tolerance
+ * widens to `DEPTH_SWING_WIDTH` of it — the temporal resolve's answer to a crack of light round a
+ * door, as a held peak rather than its running mean: a rail caught in one phase of eighteen misses
+ * once a period, and a mean has worn that miss down to a thirtieth by the next. **What it gives up**
+ * is the depth test's word at such a pixel while still: a surface arriving there inside the swing
+ * keeps the history, and the neighbourhood clip, which the unproven sample of an arrival leaves
+ * unwidened, is what takes it out.
+ *
  * **Conventions.** Images are rows from `v = 0` upward. Depths are clip depths in the matrices'
  * convention, OpenGL's here — the nearest is the smallest — and the renderer converts its reversed
  * buffer before a sample reaches this arithmetic, as the temporal resolve already does.
@@ -37,6 +60,7 @@
 import { clipToBox, rgbToYCoCg, varianceBox, yCoCgToRgb } from './clamp.js';
 import { disocclusionWeight, normalFromPositions, planarity, surfaceSlope, worldPositionFromDepth, } from './disocclusion.js';
 import { sampleBilinear, sampleHistoryBicubic5 } from './reproject.js';
+import { TEMPORAL_FLICKER, flickerBlend, flickerRule, flickerWidening, freshFlicker, nextFlicker, stillness, } from '../temporalAa.js';
 /**
  * A tenth of each frame kept, as the temporal resolve keeps; a box of a standard deviation and a
  * quarter; a light sharpen. At two thirds of the output a side.
@@ -98,6 +122,12 @@ export function reconstructionWeight(dx, dy) {
  * pixel away.
  */
 export const CONFIDENT_WEIGHT = 1;
+/**
+ * How many of its held depth swings a still pixel's depth test tolerates. The peak halves over a
+ * period, so the frame before the next once-a-period miss holds just over half of it: tolerating
+ * twice the peak passes that miss outright, and three leaves the same room again.
+ */
+export const DEPTH_SWING_WIDTH = 3;
 const SAMPLE = new Float32Array(3);
 const GATHERED = new Float64Array(3);
 const HISTORY = new Float32Array(4);
@@ -113,6 +143,37 @@ const UP = new Float64Array(3);
 const NORMAL = new Float64Array(3);
 const PREVIOUS_NORMAL = new Float64Array(3);
 const CLIP = new Float64Array(4);
+/** The last frame's reprojection, derived once a frame rather than once a pixel. */
+const REPROJECTION = new Float64Array(16);
+let reprojected = null;
+/** `frame.reprojection`, or the product of its two matrices, multiplied once per frame. */
+function reprojectionOf(frame) {
+    if (frame.reprojection !== undefined)
+        return frame.reprojection;
+    if (reprojected !== frame) {
+        reprojected = frame;
+        const a = frame.previousViewProj;
+        const b = frame.inverseViewProj;
+        for (let c = 0; c < 4; c += 1) {
+            for (let r = 0; r < 4; r += 1) {
+                let sum = 0;
+                for (let k = 0; k < 4; k += 1)
+                    sum += a[k * 4 + r] * b[c * 4 + k];
+                REPROJECTION[c * 4 + r] = sum;
+            }
+        }
+    }
+    return REPROJECTION;
+}
+const HELD = { spread: 0, sum: 0, mean: 0, repeated: 0 };
+const CARRIED = { spread: 0, sum: 0, mean: 0, repeated: 0 };
+/** How far, in output pixels, the last `historyWeight` found its surface had moved. */
+let moved = 0;
+/** How far, relative, last frame's depth missed the one expected there; -1 where nothing was held. */
+let missed = -1;
+/** The rule for the last period asked for, kept: one is made per period, not per pixel. */
+let rulePhases = 0;
+let rule = TEMPORAL_FLICKER;
 function clampTexel(value, size) {
     return value < 0 ? 0 : value >= size ? size - 1 : value;
 }
@@ -184,7 +245,8 @@ function normalAt(depths, inverse, jitter, eye, width, height, x, y, out) {
  * was behind last frame's eye or off its picture, and otherwise what it gathered, scaled by whether it
  * is the same surface. Reads `HISTORY`; writes the history's colour there.
  */
-function historyWeight(frame, u, v, dx, dy) {
+function historyWeight(frame, u, v, dx, dy, swing) {
+    missed = -1;
     if (!frame.hasHistory)
         return 0;
     const rw = frame.renderWidth;
@@ -199,27 +261,45 @@ function historyWeight(frame, u, v, dx, dy) {
         expected = frame.motion[flagAt + 2];
     }
     else {
-        if (worldAt(frame.depth, frame.inverseViewProj, frame.jitter, rw, rh, dx, dy, WORLD) <= 0) {
+        /*
+         * **Through one matrix, last frame's view-projection times this frame's inverse**, rather than
+         * out to a world position and back. The two are the same arithmetic in exact numbers; in single
+         * precision the round trip is not the identity — a near plane a quarter of a metre from a far one
+         * five kilometres off — and a still camera measured a few hundredths of a pixel of motion growing
+         * out from the middle of the frame, which crept every still history and kept every pixel from
+         * the anti-flicker's stillness. The product is taken where the precision is (`reprojection`),
+         * and for a still camera it is the identity.
+         */
+        const du = (dx + 0.5 - frame.jitter[0]) / rw;
+        const dv = (dy + 0.5 - frame.jitter[1]) / rh;
+        const x = du * 2 - 1;
+        const y = dv * 2 - 1;
+        const z = frame.depth[dy * rw + dx];
+        const inverse = frame.inverseViewProj;
+        /* The homogeneous w of the world position: none, or behind the eye, is no surface. */
+        const hw = inverse[3] * x +
+            inverse[7] * y +
+            inverse[11] * z +
+            inverse[15];
+        if (!(hw > 1e-12))
             return 0;
-        }
-        const m = frame.previousViewProj;
+        const m = reprojectionOf(frame);
         for (let r = 0; r < 4; r += 1) {
             CLIP[r] =
-                m[r] * WORLD[0] +
-                    m[4 + r] * WORLD[1] +
-                    m[8 + r] * WORLD[2] +
+                m[r] * x +
+                    m[4 + r] * y +
+                    m[8 + r] * z +
                     m[12 + r];
         }
         /*
          * A surface behind last frame's eye has a w that is not positive: the disocclusion trusts no
          * such depth, so it needs no refusal of its own here.
          */
-        expected = CLIP[3];
-        const du = (dx + 0.5 - frame.jitter[0]) / rw;
-        const dv = (dy + 0.5 - frame.jitter[1]) / rh;
-        mu = (CLIP[0] / expected) * 0.5 + 0.5 - du;
-        mv = (CLIP[1] / expected) * 0.5 + 0.5 - dv;
+        expected = CLIP[3] / hw;
+        mu = (CLIP[0] / CLIP[3]) * 0.5 + 0.5 - du;
+        mv = (CLIP[1] / CLIP[3]) * 0.5 + 0.5 - dv;
     }
+    moved = Math.hypot(mu * frame.outputWidth, mv * frame.outputHeight);
     const pu = u + mu;
     const pv = v + mv;
     if (!(pu >= 0 && pu <= 1 && pv >= 0 && pv <= 1))
@@ -284,14 +364,18 @@ function historyWeight(frame, u, v, dx, dy) {
             NORMAL[2] * PREVIOUS_NORMAL[2];
         normalDot = 1 - planar * (1 - cosine);
     }
-    const trust = disocclusionWeight(expected, held, Math.hypot(mu, mv), normalDot, frame.disocclusion, slope);
+    if (held > 0 && expected > 0)
+        missed = Math.abs(held - expected) / expected;
+    /* A still pixel's own depth swing, as wide as the anti-flicker's box: see the header. */
+    const swung = swing > 0 ? DEPTH_SWING_WIDTH * swing * stillness(moved) : 0;
+    const trust = disocclusionWeight(expected, held, Math.hypot(mu, mv), normalDot, frame.disocclusion, slope + swung);
     return HISTORY[3] * trust;
 }
 /**
  * One output pixel: the history's next colour, before sharpening, and the weight it has gathered —
- * four values into `out`.
+ * four values into `out` — and, where the frame carries records, the pixel's next one into `record`.
  */
-export function resolvePixel(frame, ox, oy, out) {
+export function resolvePixel(frame, ox, oy, out, record, swingOut) {
     const rw = frame.renderWidth;
     const rh = frame.renderHeight;
     const ow = frame.outputWidth;
@@ -339,8 +423,57 @@ export function resolvePixel(frame, ox, oy, out) {
     for (let c = 0; c < 3; c += 1)
         GATHERED[c] = GATHERED[c] / gathered;
     /* 3 and 4. The history, and the weight it still deserves. */
-    const cap = (1 - frame.quality.alpha) / frame.quality.alpha;
-    const kept = Math.min(cap, historyWeight(frame, u, v, dx, dy));
+    const alpha = frame.quality.alpha;
+    const records = frame.flicker;
+    const anti = records !== undefined && records !== null;
+    if (anti) {
+        const phases = frame.flickerPhases ?? 0;
+        if (phases !== rulePhases) {
+            rulePhases = phases;
+            rule = phases > 0 ? flickerRule(phases) : TEMPORAL_FLICKER;
+        }
+    }
+    const swings = frame.depthSwing;
+    const swing = anti && swings !== undefined && swings !== null ? swings[oy * ow + ox] : 0;
+    const weight = historyWeight(frame, u, v, dx, dy, swing);
+    let cap = (1 - alpha) / alpha;
+    /* The anti-flicker: a proven pixel's box widened by its spread, and more of its history kept. */
+    if (anti) {
+        const sample = GATHERED[0] * 0.2126 +
+            GATHERED[1] * 0.7152 +
+            GATHERED[2] * 0.0722;
+        const at = (oy * ow + ox) * 4;
+        if (weight > 0) {
+            HELD.spread = records[at];
+            HELD.sum = records[at + 1];
+            HELD.mean = records[at + 2];
+            HELD.repeated = records[at + 3];
+        }
+        else {
+            freshFlicker(HELD, sample, rule);
+        }
+        const still = weight > 0 ? stillness(moved) : 0;
+        const widen = flickerWidening(HELD, sample, still, rule);
+        for (let c = 0; c < 3; c += 1) {
+            LOW[c] = LOW[c] - widen;
+            HIGH[c] = HIGH[c] + widen;
+        }
+        const keep = flickerBlend(1 - alpha, HELD, sample, still, rule);
+        cap = keep / (1 - keep);
+        nextFlicker(CARRIED, HELD, sample, still, frame.periodStart === true, rule);
+        if (record !== undefined) {
+            record[0] = CARRIED.spread;
+            record[1] = CARRIED.sum;
+            record[2] = CARRIED.mean;
+            record[3] = CARRIED.repeated;
+        }
+        /* The peak carried on, halving over a period, whatever the test said; none where nothing was
+           held to miss. */
+        if (swingOut !== undefined) {
+            swingOut[0] = missed >= 0 ? Math.max(missed, swing * 0.5 ** rule.memory) : 0;
+        }
+    }
+    const kept = Math.min(cap, weight);
     /* 5. Clipped, mixed by weight, and the gaps filled from the render. */
     const total = kept + gathered;
     if (kept > 0) {
@@ -359,6 +492,8 @@ export function resolvePixel(frame, ox, oy, out) {
     out[3] = total;
 }
 const TAP = new Float32Array(4);
+const RECORD = new Float32Array(4);
+const SWING = new Float32Array(1);
 const CENTRE = new Float32Array(4);
 const AROUND = new Float32Array(12);
 const SHOWN = new Float32Array(3);
@@ -370,15 +505,21 @@ const OFFSETS = [
 ];
 /**
  * The whole frame: the next history into `history`, four floats a pixel, and the picture shown into
- * `shown`, three — the history sharpened against the four direct neighbours it has just been given.
+ * `shown`, three — the history sharpened against the four direct neighbours it has just been given —
+ * and, where the frame carries records, the next ones into `records`, four floats a pixel, and the
+ * next depth swings into `swings`, one.
  */
-export function resolveFrame(frame, history, shown) {
+export function resolveFrame(frame, history, shown, records, swings) {
     const ow = frame.outputWidth;
     const oh = frame.outputHeight;
     for (let y = 0; y < oh; y += 1) {
         for (let x = 0; x < ow; x += 1) {
-            resolvePixel(frame, x, y, TAP);
+            resolvePixel(frame, x, y, TAP, RECORD, SWING);
             history.set(TAP, (y * ow + x) * 4);
+            if (records !== undefined)
+                records.set(RECORD, (y * ow + x) * 4);
+            if (swings !== undefined)
+                swings[y * ow + x] = SWING[0];
         }
     }
     for (let y = 0; y < oh; y += 1) {

package/dist/render/renderQuality.d.ts

@@ -29,6 +29,8 @@ export type OutputTransform = 'none' | 'srgb' | 'aces';
 export type ShadowFilterTaps = 4 | 8 | 12;
 export type DirectionalShadowDepthLayers = 1 | 2;
 export type WaterReflectionFilterTaps = 1 | 5 | 9;
+/** How light through glass is coloured: see `RenderQuality.glassShadows`. */
+export type GlassShadows = 'full' | 'half' | 'off';
 export interface RenderQuality {
     /**
      * The transfer curve applied at the end of every shaded pass.
@@ -141,6 +143,25 @@ export interface RenderQuality {
     readonly lightVolumeSamples: number;
     /** Independently composited static sun depths; two preserves common overlaps. */
     readonly directionalShadowDepthLayers: DirectionalShadowDepthLayers;
+    /**
+     * Whether light through glass takes the glass's colour, and at what size.
+     *
+     * **`'full'`, the default**: every shadow a glass caster reaches gains a layer holding the depth of
+     * the nearest pane and a tint layer holding what the panes let through, at the size of the depth
+     * map beside it — 8 bytes a texel, so 32 MB for a 2048 sun map and 8 MB for a 1024 lamp layer.
+     * **`'half'`** halves the tint layers only (the glass depth must match its array): 20 MB and 5 MB,
+     * and a coloured patch softer than an opaque shadow's edge. **`'off'`** is glass before this
+     * existed: a pane casts nothing at all.
+     *
+     * Nothing is allocated until a glass caster first reaches a shadow, so a scene with no glass pays
+     * no memory and no pass whatever this says. **The lit shader is the exception**: `'full'` and
+     * `'half'` compile the glass lookup into it, and a lookup that finds no glass and returns at its
+     * first line still costs the lit pass its registers — measured on the courtyard at night, 0.27 ms
+     * at 720p on WebGPU, 0.42 ms on WebGL2 and 1.2 ms at 4K. `'off'` compiles none of it, so a world
+     * that never casts through glass is that much faster for saying so. What would make `'full'` wrong
+     * is a phone budget with a lot of glass; that is what `'half'` is for. See `glassShadow.ts`.
+     */
+    readonly glassShadows: GlassShadows;
     /** Horizontal world-space reach over which a directional shadow dissolves. */
     readonly directionalShadowMaxDistance: number;
     /** Maximum horizontal projection per vertical metre before low-angle shadows vanish. */
@@ -548,6 +569,20 @@ export interface RenderQuality {
      * the render is a quarter of the output and no reconstruction holds an edge through that. A
      * negative number is off, not a clamp to the bottom: it cannot mean "a little".
      *
+     * **What it needs from you.** A `createMover()` per moving object, passed with that object's
+     * draws where `drawMesh` takes last frame's matrix — the renderer keeps last frame's model and,
+     * for a skinned draw, last frame's pose. Instanced batches and meshes rewritten with
+     * `updateMesh` need nothing: the batch and the mesh are their own identity. And `cameraCut()` at
+     * every cut, because nothing detects one: without it a cut blends the previous shot into the
+     * next. Blended draws — translucent meshes, particles, plumes, film, bolts, lines, world text —
+     * are drawn after the upscale at the output size and need nothing either; light volumes stay in
+     * the reconstructed picture, being a march that keeps its history.
+     *
+     * **What it cannot give back** is the resolution it draws at: an edge that never moves is softer
+     * than a native frame's at any ratio, because two thirds of the pixels at 1.5 are a guess made
+     * sharp. Measured on `demo/dev/ghost.html` against a native frame at four samples, still edges
+     * err by about 8 levels where a native frame at one sample errs by 3.
+     *
      * `?recon=` is how it gets A/B'd in one reload.
      */
     readonly reconstruction: number;

package/dist/render/renderQuality.js

@@ -56,6 +56,7 @@ export const DEFAULT_RENDER_QUALITY = Object.freeze({
     shadowFilterTaps: MAX_SHADOW_FILTER_TAPS,
     lightVolumeSamples: 32,
     directionalShadowDepthLayers: 2,
+    glassShadows: 'full',
     directionalShadowMaxDistance: 6,
     directionalShadowMaxSlope: 3,
     pointShadowRebakeDistance: 0.001,
@@ -205,6 +206,7 @@ export function resolveRenderQuality(options = {}) {
         shadowFilterTaps: options.shadowFilterTaps ?? DEFAULT_RENDER_QUALITY.shadowFilterTaps,
         lightVolumeSamples: options.lightVolumeSamples ?? DEFAULT_RENDER_QUALITY.lightVolumeSamples,
         directionalShadowDepthLayers: options.directionalShadowDepthLayers ?? DEFAULT_RENDER_QUALITY.directionalShadowDepthLayers,
+        glassShadows: options.glassShadows ?? DEFAULT_RENDER_QUALITY.glassShadows,
         directionalShadowMaxDistance: options.directionalShadowMaxDistance ?? DEFAULT_RENDER_QUALITY.directionalShadowMaxDistance,
         directionalShadowMaxSlope: options.directionalShadowMaxSlope ?? DEFAULT_RENDER_QUALITY.directionalShadowMaxSlope,
         pointShadowRebakeDistance: options.pointShadowRebakeDistance ?? DEFAULT_RENDER_QUALITY.pointShadowRebakeDistance,
@@ -286,6 +288,11 @@ export function resolveRenderQuality(options = {}) {
     if (quality.directionalShadowDepthLayers !== 1 && quality.directionalShadowDepthLayers !== 2) {
         throw new Error(`RenderQuality.directionalShadowDepthLayers must be 1 or 2, got ${quality.directionalShadowDepthLayers}`);
     }
+    if (quality.glassShadows !== 'full' &&
+        quality.glassShadows !== 'half' &&
+        quality.glassShadows !== 'off') {
+        throw new Error(`RenderQuality.glassShadows must be 'full', 'half' or 'off', got ${String(quality.glassShadows)}`);
+    }
     if (quality.plumeNoiseOctaves > 3) {
         throw new Error(`RenderQuality.plumeNoiseOctaves must be <= 3, got ${quality.plumeNoiseOctaves}`);
     }

package/dist/render/rendererHarness.js

@@ -29,6 +29,10 @@ export function recordingGl(options = {}) {
     const programFragments = new WeakMap();
     const calls = [];
     const constants = {
+        /* The canvas's size, as a real context reports its drawing buffer; a function here made every
+           jitter and every per-pixel offset divided by it a NaN. */
+        drawingBufferWidth: 640,
+        drawingBufferHeight: 480,
         ACTIVE_UNIFORMS: 0x8b86,
         ACTIVE_ATTRIBUTES: 0x8b89,
         COMPILE_STATUS: 0x8b81,
@@ -86,6 +90,18 @@ export function recordingGl(options = {}) {
         COLOR_BUFFER_BIT: 0x00004000,
         /* Named so a test can tell a mesh that declared itself deforming from one that did not. */
         ARRAY_BUFFER: 0x8892,
+        /* Named so a blend a pass sets can be read back as numbers: glass multiplies what it lets
+           through, and a test that cannot tell DST_COLOR from a recorder cannot tell it multiplies. */
+        ZERO: 0,
+        DST_ALPHA: 0x0304,
+        DST_COLOR: 0x0306,
+        FUNC_ADD: 0x8006,
+        COLOR: 0x1800,
+        DEPTH: 0x1801,
+        /* Named so a copy can be read as from-and-to: a blit's two framebuffers are the whole claim. */
+        READ_FRAMEBUFFER: 0x8ca8,
+        DRAW_FRAMEBUFFER: 0x8ca9,
+        BLEND: 0x0be2,
         STATIC_DRAW: 0x88e4,
         DYNAMIC_DRAW: 0x88e8,
     };

package/dist/render/sceneTarget.d.ts

@@ -72,6 +72,8 @@ export declare class SceneTarget {
     private colorCopyFramebuffer;
     /** Whether this frame has filled it. One snapshot serves every refracting draw in a frame. */
     private colorCopyFilled;
+    /** Whether this frame's copy has its mip chain, which frosted glass reads. See `snapshotColor`. */
+    private colorCopyMips;
     /**
      * The colour grade, as a 3D texture on unit 4, and the table it was built from.
      *
@@ -221,7 +223,11 @@ export declare class SceneTarget {
      * Null where the copy could not be made, and a caller must read that as "do not refract" rather
      * than as a black texture — refracting against black paints every pane the colour of a hole.
      */
-    snapshotColor(afresh?: boolean): WebGLTexture | null;
+    snapshotColor(afresh?: boolean, 
+    /** Fill the copy's mip chain as well, once a frame: what frosted glass reads. */
+    mips?: boolean): WebGLTexture | null;
+    /** The copy's mip chain from its level 0, once per copy. */
+    private fillColorCopyMips;
     snapshotDepth(
     /**
      * Take the copy again even though one has already been taken this frame.
@@ -287,6 +293,8 @@ export declare class SceneTarget {
         /** The projection's x and y scales, which turn a world radius into a screen one. */
         readonly projScale: Float32Array;
         readonly invProjection: Float32Array;
+        /** Where the frame's jitter put the occlusion, in uv: see the shader's `uAoOffset`. */
+        readonly offset?: Float32Array;
     }, bloom?: {
         readonly strength: number;
         /** In scene units, which is why this wants `keepsRange`. See `BloomPass`. */

package/dist/render/sceneTarget.js

@@ -76,6 +76,8 @@ export class SceneTarget {
     colorCopyFramebuffer = null;
     /** Whether this frame has filled it. One snapshot serves every refracting draw in a frame. */
     colorCopyFilled = false;
+    /** Whether this frame's copy has its mip chain, which frosted glass reads. See `snapshotColor`. */
+    colorCopyMips = false;
     /**
      * The colour grade, as a 3D texture on unit 4, and the table it was built from.
      *
@@ -241,13 +243,25 @@ export class SceneTarget {
         if (this.colorCopy === null)
             this.colorCopy = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, this.colorCopy);
-        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);
+        /*
+         * **Every level, so glass can read a blurrier one.** Frosted glass reads the copy at a level its
+         * frost picks, and a texture sampled through a mipmapping filter with a level missing is
+         * incomplete and reads black — so the chain is allocated here, once per size, and filled only on
+         * a frame that draws glass (`snapshotColor`). Plain refraction reads level 0, as it always has.
+         */
+        const levels = Math.floor(Math.log2(Math.max(width, height))) + 1;
+        for (let level = 0; level < levels; level += 1) {
+            const w = Math.max(1, width >> level);
+            const h = Math.max(1, height >> level);
+            if (this.floatColor) {
+                gl.texImage2D(gl.TEXTURE_2D, level, gl.RGBA16F, w, h, 0, gl.RGBA, gl.HALF_FLOAT, null);
+            }
+            else {
+                gl.texImage2D(gl.TEXTURE_2D, level, gl.RGBA, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+            }
         }
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, levels - 1);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_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);
@@ -359,6 +373,7 @@ export class SceneTarget {
         /* Last frame's snapshot is last frame's scene. See `snapshotDepth`. */
         this.depthCopyFilled = false;
         this.colorCopyFilled = false;
+        this.colorCopyMips = false;
         this.bind();
     }
     /**
@@ -449,15 +464,22 @@ export class SceneTarget {
      * Null where the copy could not be made, and a caller must read that as "do not refract" rather
      * than as a black texture — refracting against black paints every pane the colour of a hole.
      */
-    snapshotColor(afresh = false) {
+    snapshotColor(afresh = false, 
+    /** Fill the copy's mip chain as well, once a frame: what frosted glass reads. */
+    mips = false) {
         if (this.colorCopy === null || this.colorCopyFramebuffer === null)
             return null;
-        if (this.colorCopyFilled && !afresh)
+        if (this.colorCopyFilled && !afresh) {
+            if (mips)
+                this.fillColorCopyMips();
             return this.colorCopy;
+        }
         const { gl } = this;
         const source = this.msaaFramebuffer ?? this.framebuffer;
         if (source === null)
             return null;
+        const drawing = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+        const reading = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
         gl.bindFramebuffer(gl.READ_FRAMEBUFFER, source);
         gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.colorCopyFramebuffer);
         /* Drained first, for the reason `resolve` gives at length: `getError` reports whatever is
@@ -470,13 +492,34 @@ export class SceneTarget {
            choice only decides which refusals are possible. */
         gl.blitFramebuffer(0, 0, this.width, this.height, 0, 0, this.width, this.height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
         const refused = gl.getError() !== gl.NO_ERROR;
-        /* Back to what the caller was drawing into, whichever that was. */
-        gl.bindFramebuffer(gl.FRAMEBUFFER, source);
+        /*
+         * **Back to what the caller was drawing into, whichever that was** — read before the copy and
+         * handed back, never assumed. It was the scene's framebuffer, assumed, and a pane drawn into a
+         * reflection probe's face then left the scene's bound: the probe attached its next face to it,
+         * a face-sized colour beside a screen-sized depth, and every draw after refused as incomplete.
+         */
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, drawing);
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, reading);
         if (refused)
             return null;
         this.colorCopyFilled = true;
+        this.colorCopyMips = false;
+        if (mips)
+            this.fillColorCopyMips();
         return this.colorCopy;
     }
+    /** The copy's mip chain from its level 0, once per copy. */
+    fillColorCopyMips() {
+        if (this.colorCopyMips || this.colorCopy === null)
+            return;
+        const { gl } = this;
+        /* Bound on whichever unit is active and handed back, so the caller's texture there survives. */
+        const previous = gl.getParameter(gl.TEXTURE_BINDING_2D);
+        gl.bindTexture(gl.TEXTURE_2D, this.colorCopy);
+        gl.generateMipmap(gl.TEXTURE_2D);
+        gl.bindTexture(gl.TEXTURE_2D, previous);
+        this.colorCopyMips = true;
+    }
     snapshotDepth(
     /**
      * Take the copy again even though one has already been taken this frame.
@@ -499,6 +542,8 @@ export class SceneTarget {
         const source = this.msaaFramebuffer ?? this.framebuffer;
         if (source === null)
             return null;
+        const drawing = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+        const reading = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
         gl.bindFramebuffer(gl.READ_FRAMEBUFFER, source);
         gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.depthCopyFramebuffer);
         /* Drained first, for the reason `resolve` gives at length: `getError` reports whatever is
@@ -509,8 +554,9 @@ export class SceneTarget {
         }
         gl.blitFramebuffer(0, 0, this.width, this.height, 0, 0, this.width, this.height, gl.DEPTH_BUFFER_BIT, gl.NEAREST);
         const refused = gl.getError() !== gl.NO_ERROR;
-        /* Back to what the caller was drawing into, whichever that was. */
-        gl.bindFramebuffer(gl.FRAMEBUFFER, source);
+        /* Back to what the caller was drawing into, read rather than assumed: see `snapshotColor`. */
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, drawing);
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, reading);
         if (refused)
             return null;
         this.depthCopyFilled = true;
@@ -788,6 +834,8 @@ export class SceneTarget {
         gl.bindTexture(gl.TEXTURE_2D, aoTexture ?? scene);
         gl.uniform1i(this.uniforms['uAo'] ?? null, 2);
         gl.uniform1f(this.uniforms['uAoStrength'] ?? null, aoTexture === null ? 0 : (ao?.strength ?? 0));
+        const offset = ao?.offset;
+        gl.uniform2f(this.uniforms['uAoOffset'] ?? null, offset?.[0] ?? 0, offset?.[1] ?? 0);
         /* Bloom on its own unit, and the placeholder for the same reason as the one above: a
            driver may fetch a texture's descriptor before it evaluates the branch that skips the
            read, and an incomplete texture is not a thing to hand it. */

package/dist/render/shaders/depth.d.ts

@@ -23,7 +23,7 @@ export declare const DEPTH_INSTANCED_VERT: string;
  */
 export declare const DEPTH_CUTOUT_VERT: string;
 export declare const DEPTH_INSTANCED_CUTOUT_VERT: string;
-export declare const DEPTH_FRAG = "#version 300 es\nprecision highp float;\nin vec4 vLightPosition;\n\nuniform highp sampler2D uPreviousShadowMap;\nuniform int uPeelShadowLayer;\n\nvoid main() {\n  if (uPeelShadowLayer != 0) {\n    vec3 p = vLightPosition.xyz / vLightPosition.w;\n    vec2 uv = p.xy * 0.5 + 0.5;\n    float previousDepth = texture(uPreviousShadowMap, uv).r;\n    // Discard the already-recorded surface and everything in front of it. The\n    // ordinary depth test then stores the next independently fading occluder.\n    if (gl_FragCoord.z <= previousDepth + 0.00001) discard;\n  }\n}\n";
+export declare const DEPTH_FRAG = "#version 300 es\nprecision highp float;\nin vec4 vLightPosition;\n\nuniform highp sampler2DArray uPreviousShadowMap;\nuniform int uPeelShadowLayer;\n\nvoid main() {\n  if (uPeelShadowLayer != 0) {\n    vec3 p = vLightPosition.xyz / vLightPosition.w;\n    vec2 uv = p.xy * 0.5 + 0.5;\n    float previousDepth = texture(uPreviousShadowMap, vec3(uv, 0.0)).r;\n    // Discard the already-recorded surface and everything in front of it. The\n    // ordinary depth test then stores the next independently fading occluder.\n    if (gl_FragCoord.z <= previousDepth + 0.00001) discard;\n  }\n}\n";
 /**
  * The cutout caster's depth: the plain pass, and a texel of alpha under the cutoff writes nothing.
  *
@@ -37,3 +37,18 @@ export declare const DEPTH_FRAG = "#version 300 es\nprecision highp float;\nin v
  * map takes the next.
  */
 export declare const DEPTH_CUTOUT_FRAG: string;
+/**
+ * The glass tint's vertex stages: every way a caster is drawn, with the world position handed on.
+ *
+ * **The same five as the depth pass, and for the same reason**: a pane must cast its colour from
+ * exactly where it casts its depth, deformed and placed the same way, or the coloured patch parts
+ * from the pane's own shadow edge. The only addition is `vGlassWorld`.
+ */
+export declare const GLASS_TINT_VERT: string;
+export declare const GLASS_TINT_SKINNED_VERT: string;
+export declare const GLASS_TINT_INSTANCED_VERT: string;
+export declare const GLASS_TINT_CUTOUT_VERT: string;
+export declare const GLASS_TINT_INSTANCED_CUTOUT_VERT: string;
+export declare const GLASS_TINT_FRAG = "#version 300 es\nprecision highp float;\nin vec4 vLightPosition;\nin vec3 vGlassWorld;\n\n/* rgb: transmission times tint; a: clarity, one less the frost. */\nuniform vec4 uGlassPane;\n/* xyz: the light's position (w 1) or the direction toward it (w 0). */\nuniform vec4 uGlassLight;\n\nout vec4 outTint;\n\nvoid main() {\n\n  vec3 n = normalize(cross(dFdx(vGlassWorld), dFdy(vGlassWorld)));\n  vec3 toLight = uGlassLight.w > 0.5 ? normalize(uGlassLight.xyz - vGlassWorld) : uGlassLight.xyz;\n  float cosLight = abs(dot(n, toLight));\n  float reflected = 0.04 + 0.96 * pow(1.0 - cosLight, 5.0);\n  outTint = vec4(uGlassPane.rgb * (1.0 - reflected), uGlassPane.a);\n\n}\n";
+/** A cut-out pane: its colour lands only where its depth does, by the depth cutout's own test. */
+export declare const GLASS_TINT_CUTOUT_FRAG: string;