@driftengine/core 4.4.0 → 4.4.2

package/CHANGELOG.json

@@ -1,4 +1,51 @@
 [
+ {
+  "version": "4.4.2",
+  "date": "2026-09-28",
+  "entries": [
+   {
+    "kind": "fixed",
+    "short": "A reconstructed frame no longer flickers or softens along the edges of still objects: the far side of every silhouette keeps its history.",
+    "text": "**The disocclusion test compared two different surfaces at every edge.** The reconstruction reprojects each output pixel by the nearest of its nine samples, the usual dilation, and then asked whether last frame held the same surface by reading last frame's depth under the output pixel rather than where the dilated sample had stood. At a silhouette those are the object and what is behind it, so the far side of every edge, every surface turned away from the eye and every part thinner than a sample dropped its history on a still frame: a paused picture flashed white along its outlines and read softer than a single frame of it.\n\nThe test now searches last frame's three by three around where the dilated sample stood, allows for how steeply the surface recedes, and weights the normal test by how planar the surface really is, so a thin rod no longer fails it. Measured on a consumer reconstructing at 1.5: a paused frame went from 3,269 flickering pixels to 338, and a still panel from up to 1,787 to 7, with no added ghosting in motion. The cost is 0.065 ms of GPU time at 2280 by 1291."
+   },
+   {
+    "kind": "fixed",
+    "short": "Temporal antialiasing no longer flashes on detail finer than a pixel while the camera is still: a paused grille, lace or crack of light holds steady.",
+    "text": "**A still pixel's neighbourhood now widens by its own proven flicker.** A thread finer than a pixel is caught by the jitter in some phases and missed in others, and in a phase that misses it the nine taps round the pixel miss it too: the box collapses onto the background, the settled history is clipped away, and a paused frame flashed at every fine edge. A still camera over a still scene samples every pixel the same way in every period of the jitter, so each pixel now keeps a small record of its own samples, and once two periods running have repeated, its box widens by the spread it has shown and it keeps more of its history. A surface that moves, a flame, or anything arriving breaks the repetition, and a sample beyond what the pixel has shown disqualifies the frame it lands in.\n\nMeasured on a scene of fine ironwork and fabric: a held frame went from 839 flickering pixels to 3 on WebGPU and from 1,802 to 14 on WebGL2, and the device check's edge figures are unchanged. It costs two half-float record targets beside the history. A moving camera is resolved exactly as before, and so is WebGL2 without float colour targets."
+   },
+   {
+    "kind": "fixed",
+    "short": "A point light's shadow no longer shows a straight-edged patch of wrong shadow while its map is redrawn: a map being sampled is re-baked whole or not at all.",
+    "text": "**A re-bake spread across frames was sampled half done.** Faces land in the layer the shader reads as they are drawn, and the origin they were drawn from is published only with the last one, so a map re-baked two faces a frame was read from its old origin with part of it drawn from the new one. A cube face is a 90 degree frustum, so the wrong part was a straight-edged quadrilateral of shadow on the ground under the lamp, and with the face budget spent elsewhere it could hold for over a second.\n\nA map that already holds an image is now re-baked whole or not at all, and a light being shaded may take one whole cube a frame outside `pointShadowFacesPerFrame`, the allowance a wandering light already had. A map with no image yet still fills a few faces a frame, since nothing samples it until it is complete. What it costs is six faces in the frame a shaded light goes stale, rather than two in each of three."
+   },
+   {
+    "kind": "fixed",
+    "short": "A flame's shadow no longer switches its own fixture in and out as the flame sways: the default near plane clears what the fire burns from at every point of the sway.",
+    "text": "**The near plane moved with the flame, and the fixture under it did not.** `createFlame` puts the light a third of the way up the flame, 0.83 of its width above what it burns from, with a near plane of one width, and sways it by 0.15 of a width on each axis. At the top of the sway the cut sat 7 mm under a 40 cm brazier's coals and at the bottom 13 cm, so the bowl beneath went in and out of the shadow map depending on where the flame stood when the map was last drawn, and the floor under the brazier took a dark disc on some re-bakes and none on others.\n\nThe default `shadowNear` now adds the sway, so it clears the same margin under the fire wherever the flame has wandered. A fixture reaching further below the flame than a sixth of its width sets its own `shadowNear` from its own depth."
+   }
+  ]
+ },
+ {
+  "version": "4.4.1",
+  "date": "2026-09-28",
+  "entries": [
+   {
+    "kind": "fixed",
+    "short": "Ambient occlusion no longer lays stripes across a surface seen edge on, or darkens one with nothing on it: a far floor or a ramp reads smooth and open.",
+    "text": "**The blur refused every neighbour of a surface seen edge on**, because it compared each tap's depth with the centre's: a floor forty metres out changes its depth by four percent a row, twice the tolerance, so the pass down the frame kept the centre alone and the estimate's rotation pattern stayed on screen as four-pixel stripes across every ramp and far floor. A tap is now compared with the depth this pixel's own plane predicts there, which is exact because 1/z is affine across a plane, so it is refused only for leaving the surface. Measured on a game's ramp at night, the row-to-row ripple fell from 0.028 to 0.0017, and silhouettes are unchanged.\n\n**And the estimate is stored at half scale.** On a plane turned from the eye one of a pixel's two lines sees more than the whole sky and the other less, and only the average over every turn is exactly one; an eight-bit target clipped each turn above one before the blur could average it, so an open plane seen at 80° came back 3.6% shaded. Scenes with occlusion on change where they have surfaces seen edge on."
+   },
+   {
+    "kind": "fixed",
+    "short": "A light that declines to cast no longer moves every lamp after it onto its neighbour's shadow, so street lamps keep their own shadows while a car's headlights are on.",
+    "text": "**`updatePointShadows` published each shadow at the wrong place after a light that declines to cast.** The shader reads a light's shadow at the light's own place in the shaded list; the lights that cast were gathered into a shorter list first, and each shadow was published at its place in that one. So a light with `castsShadow: false` moved every casting light after it one place down: the first lamp's shadow landed on the declining light and each lamp after it wore the next one's. A light riding a camera or a car is exactly the light that declines, and it is nearly always shaded first. The place is now kept, and left empty.\n\nA consumer that worked around this by handing over only the lights before the first one that declines can hand over the whole count. That cap is what switched lamps' shadows on and off as a car moved, because which lamps rank ahead of its headlights changes with every metre."
+   },
+   {
+    "kind": "fixed",
+    "short": "The published packages carry only what the engine is: no local build caches in the packager, and no compiled leftovers of modules since deleted.",
+    "text": "**`@driftengine/package` had shipped the packager's local Gradle caches and a build report since at least 4.2.0.** Its `files` names `android` whole, and the ignore rules for that directory's build output live in the repository's `.gitignore`, which npm does not read for a package. Nineteen files, none of them the engine's and none carrying a path or a name from the machine that built them, checked; they are excluded now, with the rest of what an Android build writes.\n\n**And 4.4.0 shipped two modules whose sources had been deleted**, `core`'s `render/shaders/agx.js` and `texture`'s `tensor/reuse.js`, because the build wrote into `dist` and never emptied it. It empties it first now, and `npm run cleanroom` refuses a tarball holding any file that is neither tracked nor built from a source that exists."
+   }
+  ]
+ },
  {
   "version": "4.4.0",
   "date": "2026-09-28",

package/README.md

@@ -2,7 +2,7 @@
 
 The runtime everything needs: renderer, loop, camera, input, geometry. Collision and dynamics live in [`@driftengine/physics`](../physics/README.md), which this package depends on and re-exports whole, so reaching for them through this barrel works as it always did.
 
-**Cost: 789.3 KB gzipped, importing `createRenderer`.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
+**Cost: 795.8 KB gzipped, importing `createRenderer`.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
 3% — the number is a fact about the build rather than a claim in a document.
 
 Part of [DriftEngine](../../README.md). See [`docs/ARCHITECTURE.md`](../../docs/ARCHITECTURE.md)

package/dist/render/ambientOcclusionPass.js

@@ -1,4 +1,4 @@
-import { AO_BLUR_FRAG, AO_FRAG } from './shaders/ambientOcclusion.js';
+import { AO_BLUR_FRAG, AO_FRAG, AO_STORE } from './shaders/ambientOcclusion.js';
 import { FULLSCREEN_VERT } from './shaders/fullscreen.js';
 import { compileProgram, uniformLocations } from './shader.js';
 /**
@@ -146,6 +146,8 @@ export class AmbientOcclusionPass {
         this.step[0] = 1 / width;
         this.step[1] = 0;
         gl.uniform2fv(this.blurUniforms['uStep'] ?? null, this.step);
+        /* Still at the estimate's scale, which the second axis needs whole. */
+        gl.uniform1f(this.blurUniforms['uAoScale'] ?? null, 1);
         gl.drawArrays(gl.TRIANGLES, 0, 3);
         /* And down, back into the estimate, which is the texture handed out. */
         gl.bindFramebuffer(gl.FRAMEBUFFER, this.estimateFramebuffer);
@@ -153,6 +155,8 @@ export class AmbientOcclusionPass {
         this.step[0] = 0;
         this.step[1] = 1 / height;
         gl.uniform2fv(this.blurUniforms['uStep'] ?? null, this.step);
+        /* And decoded, so the composite reads open sky as one. */
+        gl.uniform1f(this.blurUniforms['uAoScale'] ?? null, 1 / AO_STORE);
         gl.drawArrays(gl.TRIANGLES, 0, 3);
         gl.bindVertexArray(null);
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);

package/dist/render/backend/webgl2/renderer.d.ts

@@ -947,6 +947,9 @@ export declare class WebGL2Renderer implements RendererApi {
      * Scratch, filled in `endFrame`, which may not allocate.
      */
     private frameProjection;
+    /** The temporal resolve's depth-to-metres row, from the inverse of `frameProjection`. */
+    private readonly taaInvProjection;
+    private readonly taaDepthToViewZ;
     private readonly aoInvProjection;
     private readonly aoProjScale;
     /**

package/dist/render/backend/webgl2/renderer.js

@@ -626,6 +626,9 @@ export class WebGL2Renderer {
      * Scratch, filled in `endFrame`, which may not allocate.
      */
     frameProjection = null;
+    /** The temporal resolve's depth-to-metres row, from the inverse of `frameProjection`. */
+    taaInvProjection = mat4.create();
+    taaDepthToViewZ = Float32Array.of(0, 0, 0, 1);
     aoInvProjection = mat4.create();
     aoProjScale = new Float32Array(2);
     /**
@@ -4943,9 +4946,19 @@ export class WebGL2Renderer {
              * its early exit on it — so this is present every jittered frame rather than absent on some,
              * and the pass still runs and fills the history for the next one.
              */
+            /* The anti-flicker's same-surface test reads depths in metres, as the occlusion does. */
+            if (this.frameProjection !== null) {
+                mat4.invert(this.taaInvProjection, this.frameProjection);
+                this.taaDepthToViewZ[0] = this.taaInvProjection[10] ?? 0;
+                this.taaDepthToViewZ[1] = this.taaInvProjection[14] ?? 0;
+                this.taaDepthToViewZ[2] = this.taaInvProjection[11] ?? 0;
+                this.taaDepthToViewZ[3] = this.taaInvProjection[15] ?? 1;
+            }
             temporal = {
                 reprojection: this.reprojection,
                 blend: this.temporalHistoryUsable ? TEMPORAL_HISTORY_BLEND : 0,
+                periodStart: this.temporalHistory.periodStart,
+                depthToViewZ: this.taaDepthToViewZ,
             };
         }
         /*

package/dist/render/backend/webgpu/postPass.d.ts

@@ -68,7 +68,7 @@ declare const RUSH_TEXTURES: {
 export declare const AO_FRAG_FIELDS: UniformFields;
 export declare const AO_FRAG_SIZE: 96;
 export declare const AO_BLUR_FIELDS: UniformFields;
-export declare const AO_BLUR_SIZE: 32;
+export declare const AO_BLUR_SIZE: 48;
 export declare const MEDIUM_FRAG_FIELDS: UniformFields;
 export declare const MEDIUM_FRAG_SIZE: 240;
 export declare const MEDIUM_UPSAMPLE_FIELDS: UniformFields;
@@ -174,14 +174,20 @@ export declare const ADDITIVE_BLEND: GPUBlendState;
 /** A fullscreen pass over one or more inputs, writing to one colour target. */
 export declare function postPipeline(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, format: GPUTextureFormat, blend?: GPUBlendState): GPURenderPipeline;
 /**
- * The temporal resolve's block and its three inputs.
+ * The same over several colour targets, in the fragment's output order: the temporal resolve
+ * writes its picture and each pixel's flicker record in one pass. `targets` is the caller's, held
+ * rather than built per call, since this is asked for every frame.
+ */
+export declare function postPipelineTargets(cache: PipelineCache, device: GPUDevice, layout: GPUBindGroupLayout, key: string, fragment: string, targets: GPUColorTargetState[]): GPURenderPipeline;
+/**
+ * The temporal resolve's block and its four inputs.
  *
  * Named like the occlusion's beside it, and for the same reason `BLOOM_DOWNSAMPLE_FIELDS` is: a
  * block read by assumption rather than by name is a uniform written to the wrong offset, which
  * draws a plausible picture.
  */
 export declare const TAA_FRAG_FIELDS: UniformFields;
-export declare const TAA_FRAG_SIZE: 80;
+export declare const TAA_FRAG_SIZE: 112;
 export declare const TAA_UNIFORMS: 1;
 export declare const TAA_TEXTURES: {
     readonly uScene: {
@@ -194,11 +200,21 @@ export declare const TAA_TEXTURES: {
         readonly sampler: 35;
         readonly type: "sampler2D";
     };
-    readonly uDepth: {
+    readonly uFlicker: {
         readonly texture: 36;
         readonly sampler: 37;
         readonly type: "sampler2D";
     };
+    readonly uFlickerMotion: {
+        readonly texture: 38;
+        readonly sampler: 39;
+        readonly type: "sampler2D";
+    };
+    readonly uDepth: {
+        readonly texture: 40;
+        readonly sampler: 41;
+        readonly type: "sampler2D";
+    };
 };
 /**
  * The order-independent resolve's inputs. It has no uniform block of its own — the whole pass is

package/dist/render/backend/webgpu/postPass.js

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

package/dist/render/backend/webgpu/renderer.d.ts

@@ -596,6 +596,16 @@ export declare class WebGPURenderer implements RendererApi {
     private taaUniforms;
     private taaTextures;
     private taaViews;
+    /** Each pixel's flicker record, paired with the history and swapped with it: see `temporalAa.ts`. */
+    private taaRecords;
+    private taaRecordViews;
+    /** The rest of each pixel's record — depth, pull and recent swing — beside the first. */
+    private taaMotions;
+    private taaMotionViews;
+    /** The resolve's depth-to-metres row, from the inverse of `frameProjection`. */
+    private readonly taaInvProjection;
+    /** The resolve's two targets, the picture and the record, held for the pipeline cache's sake. */
+    private taaTargets;
     /** Group `i` reads history `i` and the pass writes into the other one. */
     private taaBindGroups;
     private taaWrite;

package/dist/render/backend/webgpu/renderer.js

@@ -48,9 +48,10 @@ import { reflectionTargetSize } from '../../planarReflectionDraw.js';
 import { drawingBufferSize } from '../../drawingBuffer.js';
 import { MOTION_BLUR_MAX_UV, OUTPUT_TRANSFORM_CODE, RUSH_REACH_UV } from '../../vertexDefaults.js';
 import { ExposurePass } from './exposurePass.js';
+import { AO_STORE } from '../../shaders/ambientOcclusion.js';
 import { clampAutoExposure } from '../../shaders/exposure.js';
 import { clampLocalExposure } from '../../shaders/localExposure.js';
-import { createDepthResolveLayout, createPostStageLayout, depthResolvePipeline, postPipeline, sceneColorFormat, AO_BLUR_FIELDS, AO_BLUR_FRAG_WGSL, AO_BLUR_SIZE, AO_BLUR_TEXTURES, AO_BLUR_UNIFORMS, AO_FRAG_FIELDS, AO_FRAG_SIZE, AO_FRAG_WGSL, AO_TEXTURES, AO_UNIFORMS, ADDITIVE_BLEND, BLOOM_DOWNSAMPLE_FIELDS, BLOOM_DOWNSAMPLE_FRAG_WGSL, BLOOM_PREFILTER_FIELDS, BLOOM_PREFILTER_FRAG_WGSL, BLOOM_STAGE_SIZE, BLOOM_TEXTURES, BLOOM_UNIFORMS, BLOOM_UPSAMPLE_FIELDS, BLOOM_UPSAMPLE_FRAG_WGSL, RESOLVED_DEPTH_FORMAT, RUSH_FRAG_FIELDS, RUSH_FRAG_SIZE, RUSH_FRAG_WGSL, RUSH_TEXTURES, RUSH_UNIFORMS, TAA_FRAG_FIELDS, TAA_FRAG_SIZE, TAA_TEXTURES, TAA_UNIFORMS, TEMPORAL_RESOLVE_FRAG_WGSL, MEDIUM_FRAG_FIELDS, MEDIUM_FRAG_SIZE, MEDIUM_FRAG_WGSL, MEDIUM_TEXTURES, MEDIUM_TRANSMIT_BLEND, MEDIUM_UNIFORMS, MEDIUM_UPSAMPLE_FIELDS, MEDIUM_UPSAMPLE_FRAG_WGSL, MEDIUM_UPSAMPLE_SIZE, MEDIUM_UPSAMPLE_TEXTURES, MEDIUM_UPSAMPLE_UNIFORMS, OIT_COMPOSITE_BLEND, OIT_RESOLVE_FRAG_WGSL, OIT_TEXTURES, DECAL_FRAG_FIELDS, DECAL_FRAG_SIZE, DECAL_MULTIPLY_BLEND, DECAL_PROJECT_FRAG_WGSL, DECAL_TEXTURES, DECAL_UNIFORMS, PREMULTIPLIED_OVER_BLEND, SSR_FRAG_FIELDS, SSR_FRAG_SIZE, SSR_RESOLVE_FRAG_WGSL, SSR_RESOLVE_TEXTURES, SSR_TEXTURES, SSR_TRACE_FRAG_WGSL, SSR_UNIFORMS, createOitResolveLayout, createSsrResolveLayout, } from './postPass.js';
+import { createDepthResolveLayout, createPostStageLayout, depthResolvePipeline, postPipeline, postPipelineTargets, sceneColorFormat, AO_BLUR_FIELDS, AO_BLUR_FRAG_WGSL, AO_BLUR_SIZE, AO_BLUR_TEXTURES, AO_BLUR_UNIFORMS, AO_FRAG_FIELDS, AO_FRAG_SIZE, AO_FRAG_WGSL, AO_TEXTURES, AO_UNIFORMS, ADDITIVE_BLEND, BLOOM_DOWNSAMPLE_FIELDS, BLOOM_DOWNSAMPLE_FRAG_WGSL, BLOOM_PREFILTER_FIELDS, BLOOM_PREFILTER_FRAG_WGSL, BLOOM_STAGE_SIZE, BLOOM_TEXTURES, BLOOM_UNIFORMS, BLOOM_UPSAMPLE_FIELDS, BLOOM_UPSAMPLE_FRAG_WGSL, RESOLVED_DEPTH_FORMAT, RUSH_FRAG_FIELDS, RUSH_FRAG_SIZE, RUSH_FRAG_WGSL, RUSH_TEXTURES, RUSH_UNIFORMS, TAA_FRAG_FIELDS, TAA_FRAG_SIZE, TAA_TEXTURES, TAA_UNIFORMS, TEMPORAL_RESOLVE_FRAG_WGSL, MEDIUM_FRAG_FIELDS, MEDIUM_FRAG_SIZE, MEDIUM_FRAG_WGSL, MEDIUM_TEXTURES, MEDIUM_TRANSMIT_BLEND, MEDIUM_UNIFORMS, MEDIUM_UPSAMPLE_FIELDS, MEDIUM_UPSAMPLE_FRAG_WGSL, MEDIUM_UPSAMPLE_SIZE, MEDIUM_UPSAMPLE_TEXTURES, MEDIUM_UPSAMPLE_UNIFORMS, OIT_COMPOSITE_BLEND, OIT_RESOLVE_FRAG_WGSL, OIT_TEXTURES, DECAL_FRAG_FIELDS, DECAL_FRAG_SIZE, DECAL_MULTIPLY_BLEND, DECAL_PROJECT_FRAG_WGSL, DECAL_TEXTURES, DECAL_UNIFORMS, PREMULTIPLIED_OVER_BLEND, SSR_FRAG_FIELDS, SSR_FRAG_SIZE, SSR_RESOLVE_FRAG_WGSL, SSR_RESOLVE_TEXTURES, SSR_TEXTURES, SSR_TRACE_FRAG_WGSL, SSR_UNIFORMS, createOitResolveLayout, createSsrResolveLayout, } from './postPass.js';
 import { GRADE_PLACEHOLDER_SIZE, identityGradeLut, validateGradeLut, } from '../../colourGrade.js';
 import { FILM_LOOK_WITHOUT_COMPOSITE, clampGrain, clampVignette, grainSeed, } from '../../shaders/filmLook.js';
 import { createProbeMipBindGroupLayout, createProbePrefilterBindGroupLayout, PREFILTER_UNIFORM_OFFSETS, probeLevels, probeMipPipeline, probePrefilterPipeline, PROBE_FACES, PROBE_FACE_BASIS, PROBE_FAR_M, PROBE_FOV_DEG, PROBE_MIP_UNIFORM_SIZE, PROBE_NEAR_M, } from './probePass.js';
@@ -1348,6 +1349,16 @@ export class WebGPURenderer {
     taaUniforms;
     taaTextures = [null, null];
     taaViews = [null, null];
+    /** Each pixel's flicker record, paired with the history and swapped with it: see `temporalAa.ts`. */
+    taaRecords = [null, null];
+    taaRecordViews = [null, null];
+    /** The rest of each pixel's record — depth, pull and recent swing — beside the first. */
+    taaMotions = [null, null];
+    taaMotionViews = [null, null];
+    /** The resolve's depth-to-metres row, from the inverse of `frameProjection`. */
+    taaInvProjection = new Float32Array(16);
+    /** The resolve's two targets, the picture and the record, held for the pipeline cache's sake. */
+    taaTargets = [];
     /** Group `i` reads history `i` and the pass writes into the other one. */
     taaBindGroups = [null, null];
     taaWrite = 0;
@@ -5229,6 +5240,8 @@ export class WebGPURenderer {
         this.taaLayout = createPostStageLayout(device, TAA_UNIFORMS, TAA_FRAG_SIZE, [
             { binding: TAA_TEXTURES.uScene },
             { binding: TAA_TEXTURES.uHistory },
+            { binding: TAA_TEXTURES.uFlicker },
+            { binding: TAA_TEXTURES.uFlickerMotion },
             { binding: TAA_TEXTURES.uDepth, filterable: false },
         ]);
         this.taaUniforms = device.createBuffer({
@@ -8646,8 +8659,10 @@ export class WebGPURenderer {
             return;
         const write = this.taaWrite;
         const target = this.taaViews[write];
+        const record = this.taaRecordViews[write];
+        const motion = this.taaMotionViews[write];
         const group = this.taaBindGroups[1 - write];
-        if (target === null || group === null)
+        if (target === null || record === null || motion === null || group === null)
             return;
         const { device } = this.surface;
         const f = this.taaFloats;
@@ -8656,15 +8671,34 @@ export class WebGPURenderer {
         f[at('uTexel')] = 1 / this.renderWidth;
         f[at('uTexel') + 1] = 1 / this.renderHeight;
         f[at('uHistoryBlend')] = this.temporalHistoryUsable ? TEMPORAL_HISTORY_BLEND : 0;
+        f[at('uPeriodStart')] = this.temporalHistory.periodStart ? 1 : 0;
+        /* The anti-flicker's same-surface test reads depths in metres, as the occlusion does. */
+        const depthRow = at('uDepthToViewZ');
+        if (this.frameProjection !== null) {
+            mat4.invert(this.taaInvProjection, this.frameProjection);
+            f[depthRow] = this.taaInvProjection[10] ?? 0;
+            f[depthRow + 1] = this.taaInvProjection[14] ?? 0;
+            f[depthRow + 2] = this.taaInvProjection[11] ?? 0;
+            f[depthRow + 3] = this.taaInvProjection[15] ?? 1;
+        }
+        else {
+            f[depthRow] = 0;
+            f[depthRow + 1] = 0;
+            f[depthRow + 2] = 0;
+            f[depthRow + 3] = 1;
+        }
+        f[at('uAntiFlicker')] = 1;
         device.queue.writeBuffer(this.taaUniforms, 0, this.taaStaging);
         const pass = encoder.beginRenderPass({
             label: 'post.taa',
             timestampWrites: this.gpuTimer.writesFor(),
             colorAttachments: [
                 { view: target, loadOp: 'clear', storeOp: 'store', clearValue: [0, 0, 0, 1] },
+                { view: record, loadOp: 'clear', storeOp: 'store', clearValue: [0, 0, 0, 0] },
+                { view: motion, loadOp: 'clear', storeOp: 'store', clearValue: [0, 0, 0, 0] },
             ],
         });
-        pass.setPipeline(postPipeline(this.pipelines, device, this.taaLayout, 'post.taa', TEMPORAL_RESOLVE_FRAG_WGSL, sceneColorFormat(this.quality.hdrScene)));
+        pass.setPipeline(postPipelineTargets(this.pipelines, device, this.taaLayout, 'post.taa', TEMPORAL_RESOLVE_FRAG_WGSL, this.taaTargets));
         pass.setBindGroup(0, group, [0]);
         pass.draw(3);
         pass.end();
@@ -9124,12 +9158,15 @@ export class WebGPURenderer {
            otherwise halve the blur and leave half the pattern standing. */
         const width = Math.max(1, this.aoTarget?.width ?? 1);
         const height = Math.max(1, this.aoTarget?.height ?? 1);
-        for (const [index, step] of [
-            [0, [1 / width, 0]],
-            [1, [0, 1 / height]],
+        /* Across at the estimate's own scale, which the second axis needs whole; down decoded, so the
+           composite reads open sky as one. The same two `ambientOcclusionPass.ts` writes. */
+        for (const [index, step, scale] of [
+            [0, [1 / width, 0], 1],
+            [1, [0, 1 / height], 1 / AO_STORE],
         ]) {
             f[slot(index) + at('uStep')] = step[0];
             f[slot(index) + at('uStep') + 1] = step[1];
+            f[slot(index) + at('uAoScale')] = scale;
             f[slot(index) + at('uDepthToViewZ')] = inv[10] ?? 0;
             f[slot(index) + at('uDepthToViewZ') + 1] = inv[14] ?? 0;
             f[slot(index) + at('uDepthToViewZ') + 2] = inv[11] ?? 0;
@@ -12288,7 +12325,28 @@ export class WebGPURenderer {
             });
             this.taaTextures[i] = texture;
             this.taaViews[i] = texture.createView();
+            /* The records in half float, whatever the picture's format: one of them holds metres. */
+            this.taaRecords[i]?.destroy();
+            const record = device.createTexture({
+                label: `post.taaRecord${i}`,
+                size: [width, height],
+                format: 'rgba16float',
+                usage: USAGE,
+            });
+            this.taaRecords[i] = record;
+            this.taaRecordViews[i] = record.createView();
+            this.taaMotions[i]?.destroy();
+            /* Two numbers a pixel: the depth its sample stood at, in metres, and how far that swings. */
+            const motion = device.createTexture({
+                label: `post.taaMotion${i}`,
+                size: [width, height],
+                format: 'rg16float',
+                usage: USAGE,
+            });
+            this.taaMotions[i] = motion;
+            this.taaMotionViews[i] = motion.createView();
         }
+        this.taaTargets = [{ format }, { format: 'rgba16float' }, { format: 'rg16float' }];
         this.taaWrite = 0;
         /* A resized target is a new texture, so whatever the history held is gone. */
         this.temporalHistory.invalidate();
@@ -12474,8 +12532,15 @@ export class WebGPURenderer {
             const scene = this.sceneColorView;
             const history = this.taaViews[i];
             const resolved = this.taaViews[1 - i];
-            if (scene === null || history === null || resolved === null)
+            const record = this.taaRecordViews[i];
+            const motion = this.taaMotionViews[i];
+            if (scene === null ||
+                history === null ||
+                resolved === null ||
+                record === null ||
+                motion === null) {
                 continue;
+            }
             this.taaBindGroups[i] = device.createBindGroup({
                 label: `post.taaBindGroup${i}`,
                 layout: this.taaLayout,
@@ -12483,6 +12548,8 @@ export class WebGPURenderer {
                     { binding: TAA_UNIFORMS, resource: { buffer: this.taaUniforms, size: TAA_FRAG_SIZE } },
                     ...entry(TAA_TEXTURES.uScene, scene),
                     ...entry(TAA_TEXTURES.uHistory, history),
+                    ...entry(TAA_TEXTURES.uFlicker, record),
+                    ...entry(TAA_TEXTURES.uFlickerMotion, motion),
                     ...entry(TAA_TEXTURES.uDepth, this.resolvedDepthView, true),
                 ],
             });

package/dist/render/flameLight.js

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

package/dist/render/pointShadowBudget.d.ts

@@ -45,7 +45,8 @@ ready: Uint8Array, count: number, out: Int32Array,
  */
 chronic?: Uint8Array): number;
 /**
- * The shaded lights that also cast, in the order they were shaded.
+ * The shaded lights that also cast, each at its own place in the shaded list, and −1 at the place
+ * of a light that does not.
  *
  * `castsShadow: false` says a light is not worth a cubemap. `selectPointLights` honours
  * that when it builds the *eligible* list, and that was taken for the whole promise — but
@@ -57,7 +58,16 @@ chronic?: Uint8Array): number;
  * It showed up as a shadow with nothing to throw it — a lamp that rides the camera
  * declines to cast for exactly that reason, and cast anyway.
  *
- * Writes into `out` and returns how many it wrote; allocation-free, because this runs
+ * **The place is kept rather than the gap closed, because the place is the shader's index.** The
+ * pool publishes each map under its light's position in this list, and the shader reads a light's
+ * shadow at the light's position in the shaded one. Closing the gap made the two numberings
+ * disagree after the first light that declined: every lamp shaded after it was published one
+ * place down, the first on the declining light and each of the rest on its neighbour. A consumer
+ * whose headlights decline, and are nearly always shaded first, could only keep its lamps honest by
+ * dropping the shadows of every lamp ranked after them, and which lamps those were changed as the
+ * car moved.
+ *
+ * Writes into `out` and returns how many places it wrote; allocation-free, because this runs
  * every frame.
  */
 export declare function selectCastingLights(lights: readonly {