@woosh/meep-engine 3.14.1 → 3.14.3

package/src/shade/renderer/texture/texture_write_to_gpu.js

@@ -4,7 +4,8 @@ import { to_half_float_uint16 } from "../../../core/binary/to_half_float_uint16.
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 import { dataTypeByteSize } from "../../../core/binary/type/DataTypeByteSizes.js";
 import { array_copy } from "../../../core/collection/array/array_copy.js";
-import { ColorSpace } from "./ColorSpace.js";
+import { AlphaMode } from "./source/AlphaMode.js";
+import { texture_write_level } from "./texture_write_level.js";
 import { gpu_texture_format_channel_count } from "./format/gpu_texture_format_channel_count.js";
 
 /**
@@ -82,13 +83,22 @@ function premultiply_rgba_in_place(data, data_type) {
 }
 
 /**
+ * Bring loose pixels into the shape the texture's format expects, then hand them to
+ * {@link texture_write_level}.
+ *
+ * Padding and premultiplication happen *before* the write rather than inside it, which is what keeps
+ * the primitive a primitive: it takes texels that are already correct, and a payload that arrived
+ * correct (a {@link ShadeTexelData}) skips this function entirely rather than threading a "nothing
+ * to do" flag through it.
+ *
+ * A single-level path by construction — a `Sampler2D` or an `ArrayBuffer` is one level of pixels, and
+ * any others are generated.
  *
  * @param {ShadeImage} image
  * @param {ArrayBuffer} source_data
  * @param {GPUQueue} queue
  * @param {GPUTexture} texture
  * @param {boolean} premultiplyAlpha
- * @param copySize
  */
 function texture_write_raw(
     image,
@@ -101,10 +111,6 @@ function texture_write_raw(
     const source_channel_count = image.channel_count;
     const source_bytes_per_element = dataTypeByteSize(image.data_type);
 
-    const bytes_per_pixel = source_channel_count * source_bytes_per_element;
-
-    let bytesPerRow = bytes_per_pixel * image.width;
-
     let upload_data = source_data;
 
     if (source_channel_count === 3) {
@@ -143,9 +149,6 @@ function texture_write_raw(
             );
         }
 
-        //
-        bytesPerRow = source_bytes_per_element * image.width * 4;
-
         // alpha is 1 everywhere, premultiplication is the identity
 
     } else if (premultiplyAlpha && source_channel_count === 4) {
@@ -156,46 +159,41 @@ function texture_write_raw(
         premultiply_rgba_in_place(upload_data, image.data_type);
     }
 
-    const dataLayout = {
-        offset: 0,
-        bytesPerRow: bytesPerRow
-    };
-
-    if(image.depth > 1){
-        dataLayout.rowsPerImage = image.height;
-    }
-
-    queue.writeTexture(
-        {
-            texture: texture,
-            mipLevel: 0,
-            origin: {
-                x: 0, y: 0, z: 0
-            },
-        },
-        upload_data,
-        dataLayout,
-        [image.width, image.height, image.depth]
-    )
-
+    /*
+     Row stride is no longer computed here. It comes from the texture's format, which is the only
+     thing that knows how wide a row of blocks is — and which, for the padded case above, correctly
+     reports the four channels the texture has rather than the three the image had.
+    */
+    texture_write_level(queue, texture, 0, upload_data);
 }
 
 /**
+ * Upload an image's texels into a texture.
+ *
+ * `level_count` says how many of the image's levels to write, from the base up, and is required
+ * rather than defaulted: the one caller that wants fewer than all of them — {@link TextureManager},
+ * about to run the mip generator — is the caller least able to have that decision made for it.
+ * Uploading levels the generator is about to overwrite is bytes across the bus for nothing.
  *
  * @param {ShadeImage} image
  * @param {GPUTexture} texture
  * @param {GPUQueue} queue
+ * @param {number} level_count how many levels to write; `image.level_count` for all of them
  */
 export function texture_write_to_gpu(
     image,
     texture,
-    queue
+    queue,
+    level_count
 ) {
 
     assert.defined(image, 'image');
     assert.defined(texture, 'texture');
     assert.defined(queue, 'queue');
 
+    assert.isNonNegativeInteger(level_count, 'level_count');
+    assert.greaterThan(level_count, 0, 'level_count');
+
     assert.equal(image.isShadeImage, true, "image.isShadeImage !== true");
 
     const source = image.source;
@@ -210,11 +208,38 @@ export function texture_write_to_gpu(
         depthOrArrayLayers: texture.depthOrArrayLayers,
     };
 
-    /**
-     * see https://www.realtimerendering.com/blog/gpus-prefer-premultiplication/
-     * @type {boolean}
-     */
-    const premultiplyAlpha = image.color_space !== ColorSpace.None;
+    /*
+     Asked of the image rather than re-derived here. `AlphaMode.Straight` is what `color_space !==
+     None` used to mean inline, so this is the same decision — but it is now one the image can be
+     told, which is how a payload that arrived already premultiplied (an encoder's output) says so.
+    */
+    const premultiplyAlpha = image.alpha_mode === AlphaMode.Straight;
+
+    if (source.isShadeTexelData === true) {
+        /*
+         Already in the texture's format, already laid out in rows of blocks. Nothing to pad, nothing
+         to premultiply — an encoder did both, or there was nothing to do — so the levels go straight
+         down.
+
+         A level may be absent: a streaming payload declares its whole chain up front and fills it in
+         coarsest-first, so "not here yet" is an ordinary state rather than a gap to complain about.
+        */
+        const levels = source.levels;
+
+        const upload_count = Math.min(level_count, levels.length);
+
+        for (let level = 0; level < upload_count; level++) {
+            const bytes = levels[level];
+
+            if (bytes === undefined) {
+                continue;
+            }
+
+            texture_write_level(queue, texture, level, bytes);
+        }
+
+        return;
+    }
 
     if (source.isSampler2D) {
 

package/src/shade/renderer/texture/virtual/source/VTSourceImage.d.ts

@@ -13,6 +13,14 @@
  *
  * Layers are the standard group order: [albedo, normal, orm]. Pass
  * `undefined` for layers the material doesn't have — they're masked out.
+ *
+ * **Uncompressed sources only, structurally.** Page borders are resolved here at
+ * runtime by blitting from neighbouring content, and for block-compressed data
+ * that is impossible: the border and the page interior share blocks at the seam,
+ * and re-encoding a block at runtime is machinery the engine does not have. A
+ * compressed stack has to come from a source whose tiles were produced with their
+ * borders already inside them — {@link VTSourceTiled} — which is also what
+ * {@link VTPhysicalCache#upload} means by "border already baked in".
  */
 export class VTSourceImage {
     /**

package/src/shade/renderer/texture/virtual/source/VTSourceImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VTSourceImage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/texture/virtual/source/VTSourceImage.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IAyBI;;;;;;OAMG;IACH;QAJ+E,MAAM,EAA1E,CAAC,WAAW,GAAC,gBAAgB,GAAC,eAAe,GAAC,SAAS,CAAC,EAAE;QAExC,IAAI,GAAtB,OAAO;OAajB;IAzCD;;OAEG;IACH,YAFU,MAAM,CAED;IAwCf,6BA2CC;IAED;;;;;;;OAOG;IACH,eANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,WAAW,GACT,QAAQ,CAAC,WAAW,GAAC,SAAS,CAAC,EAAE,CAAC,CAuF9C;IAED,gBAEC;;CACJ"}
+{"version":3,"file":"VTSourceImage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/texture/virtual/source/VTSourceImage.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAyBI;;;;;;OAMG;IACH;QAJ+E,MAAM,EAA1E,CAAC,WAAW,GAAC,gBAAgB,GAAC,eAAe,GAAC,SAAS,CAAC,EAAE;QAExC,IAAI,GAAtB,OAAO;OAajB;IAzCD;;OAEG;IACH,YAFU,MAAM,CAED;IAwCf,6BA2CC;IAED;;;;;;;OAOG;IACH,eANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,WAAW,GACT,QAAQ,CAAC,WAAW,GAAC,SAAS,CAAC,EAAE,CAAC,CAuF9C;IAED,gBAEC;;CACJ"}

package/src/shade/renderer/texture/virtual/source/VTSourceImage.js

@@ -15,6 +15,14 @@ import { assert } from "../../../../../core/assert.js";
  *
  * Layers are the standard group order: [albedo, normal, orm]. Pass
  * `undefined` for layers the material doesn't have — they're masked out.
+ *
+ * **Uncompressed sources only, structurally.** Page borders are resolved here at
+ * runtime by blitting from neighbouring content, and for block-compressed data
+ * that is impossible: the border and the page interior share blocks at the seam,
+ * and re-encoding a block at runtime is machinery the engine does not have. A
+ * compressed stack has to come from a source whose tiles were produced with their
+ * borders already inside them — {@link VTSourceTiled} — which is also what
+ * {@link VTPhysicalCache#upload} means by "border already baked in".
  */
 export class VTSourceImage {
 

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AA4BA;IAyHI;;;;OAIG;IACH,qDAqBC;IA/GD;;OAEG;IACH,8BAOC;IAjBD;;OAEG;IACH,2BAEC;IA6BD;;OAEG;IACH,4BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IAiND;;;;;;;OAOG;IACH;;;MAyEC;;CAEJ"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AA4BA;IAkII;;;;OAIG;IACH,qDAqBC;IAxHD;;OAEG;IACH,8BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,4BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA4ND;;;;;;;OAOG;IACH;;;MAyEC;;CAEJ"}

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -82,6 +82,15 @@ export class GPUViewVolumetrics {
      */
     #froxel_far = Infinity;
 
+    /**
+     * The froxel depth curve uploaded last frame. The TAA history is addressed on the curve it was
+     * accumulated with, so when the curve changes the history is wrong at every slice and must be
+     * dropped. Comparing the built parameters catches every input to the curve at once -- camera
+     * near, camera far, the froxel-far override -- rather than watching each separately.
+     * @type {Float32Array}
+     */
+    #froxel_curve_previous = new Float32Array(3);
+
     /**
      * @returns {number}
      */
@@ -368,6 +377,17 @@ export class GPUViewVolumetrics {
             froxel_depth_scale
         );
 
+        // Recomputed deterministically, so a steady camera compares bitwise equal and never resets.
+        {
+            const curve = volumetrics_froxel_cluster_parameters;
+            const previous = this.#froxel_curve_previous;
+
+            if (curve[0] !== previous[0] || curve[1] !== previous[1] || curve[2] !== previous[2]) {
+                previous.set(curve);
+                this.#reset_history = true;
+            }
+        }
+
         // The projection is infinite-far reverse-Z, so the camera frustum's far plane is zeroed and
         // can't be sliced into froxel slabs. Rebuild a finite far plane at the logical far for the
         // participating-media coverage test — exactly as the light-cluster assignment does.

package/src/shade/renderer/volumetrics/NOTES.md

@@ -927,3 +927,31 @@ which is what supplies each transformed plane's distance term, and
 `transpose` was missing from the WGSL emulator's language core, which is why `frustum_transform_m4`
 had never been exercised there; it is implemented now for the square matrix sizes, on the same
 footing as `determinant`.
+
+## Volumetric TAA review — 2026-09-02
+
+`taa/shader_volumetrics_taa.js`, reviewed for correctness. Each finding is its own commit, pinned
+by a spec that was red against the old code except where noted. The reprojection and the resolve
+were lifted into pure chunks first so the emulator could execute them.
+
+| item | finding | pin |
+|---|---|---|
+| history fetch | the 3x3x3 Blackman-Harris resample weighted the ±1 neighbours 8.4% each even at a zero offset, so every frame blurred the accumulation and the 0.95 feedback compounded it to ~1.8 froxels of sigma per axis, Z included. Now trilinear through the same sampler the lighting pass uses. | none, by request; validity gate |
+| reprojection | went through the previous camera's jittered VP while the reconstruction used the un-jittered CPU frustum, so a static camera missed its own texel by last frame's jitter. Now the projection diagonal on view-space xy. | a jittered previous camera must round-trip a static froxel exactly |
+| validity | a froxel behind the previous camera has negative w, the divide mirrors NDC back into frame, and the uv check passed. Now depth > 0 as well. | camera backing up past a near froxel |
+| box | the variance band excluded the centre sample whenever gamma < 1, breaking the clip's precondition; both failure paths output the raw sample. Now unioned with the centre. | 26 dark neighbours, a bright centre, the motion-end gamma |
+| resolve | damped the HISTORY to zero on clip, Karis's rule backwards: every clipped voxel output the raw 1-spp sample. Now a fixed 0.95 feedback with the incoming weight damped toward a quarter as the clamp distance reaches one. | impulse moves the resolve by ≤ W_CURRENT·Δ; clipped history kept; wall pull ≤ wide pull |
+| host | camera near/far changes rebuilt the froxel curve without a history reset. Now any change to the built curve resets. | software device, host-written `history_reset` across frames |
+
+Observed, not fixed:
+
+* The last slice (63) does not round-trip to its own texel centre. Its centre depth on the curve
+  exceeds the logical far, the reconstruction clamps it to far, and far maps back to slice 63.0
+  rather than 63.5, so trilinear reads a 50/50 of slices 62 and 63 even when static. The lighting
+  pass truncates that slab at far as well, so its stored content is not centred at 63.5 either.
+  The reprojection spec excludes the last slice from the exact round trip.
+* Box collapse. When all 27 neighbourhood samples miss a thin feature the spatial variance is
+  exactly zero, the box has zero width, and the clip erases everything the history accumulated;
+  it then climbs at 5% a frame and never reaches the mean — about a third of it at 10% coverage.
+  The damping does not touch this either way. It needs a box that knows temporal variance or a
+  width floor, and there is no drop-in for that with high confidence.

package/src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_volumetric_history_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oDAFY,SAAS,CAwEnB;0BA7EwB,oCAAoC"}
+{"version":3,"file":"chunk_volumetric_history_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oDAFY,SAAS,CA6EnB;0BAlFwB,oCAAoC"}

package/src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.js

@@ -69,8 +69,13 @@ fn volumetric_history_bounding_box(
     
     let std_dev = get_std_dev4(mean, avg_sq) * variance_gamma;
 
-    *out_min = mean - std_dev;
-    *out_max = mean + std_dev;
+    // The box must contain the centre sample: color_clip_to_aabb4 walks from the history toward
+    // it and stops at the box, which is only a clip if the target is inside. The variance band
+    // alone does not guarantee that -- with gamma below 1, one bright 1-spp sample among 26 dark
+    // neighbours sits several sigma above the mean -- and a box that excludes its own target
+    // hands the clip either the raw sample or a wall the damping reads as a full clamp.
+    *out_min = min(mean - std_dev, center_sample);
+    *out_max = max(mean + std_dev, center_sample);
 }
     `,
     [

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_reproject.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Where this frame's froxel was in last frame's froxel grid, for the volumetric TAA.
+ *
+ * Reconstructs the froxel centre in world space through the current camera's metadata frustum,
+ * then projects it through the previous camera. Returns `(prev_uvw, prev_depth)`: the first three
+ * are the history texture coordinate, the last is planar view depth in the previous camera, which
+ * `volumetrics_taa_history_valid` needs because a point behind that camera still projects to a uv
+ * in range -- the divide by a negative `w` mirrors it into the frame.
+ *
+ * A pure function of its arguments so `chunk_volumetrics_taa_reproject.spec.js` can drive it in
+ * the WGSL emulator against geometry-derived expectations; it was inline in the TAA body before.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_taa_reproject: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_volumetrics_taa_reproject.d.ts.map

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_reproject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_volumetrics_taa_reproject.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_reproject.js"],"names":[],"mappings":"AAuFA;;;;;;;;;;;;;GAaG;AACH,8CAFU,SAAS,CAoEjB;0BAjKwB,oCAAoC"}

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_reproject.js

@@ -0,0 +1,168 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_cluster_depth_from_z_slice } from "../../light/cluster/chunk_cluster_depth_from_z_slice.js";
+import { chunk_cluster_depth_to_z_slice } from "../../light/cluster/chunk_cluster_depth_to_z_slice.js";
+import { chunk_frustum_sample_point } from "../../shader/chunk/geometry/frustum/chunk_frustum_sample_point.js";
+import { chunk_ndc_to_uv } from "../../shader/chunk/texture/chunk_ndc_to_uv.js";
+import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Froxel coordinate -> a sample point for `frustum_sample_point`, NOT a froxel texture coordinate.
+ *
+ * That distinction is the whole reason this is not `volumetrics_position_world_to_froxel_uvw`
+ * turned around. There `w` is slice space -- `log2(fma(depth, x, y)) * z`, corrected by the
+ * cell-averaged content offset -- because it addresses the 3D texture. Here `w` is a LINEAR
+ * fraction of the near..far range, because its only consumer is `frustum_sample_point`, which
+ * mixes the near and far planes linearly. The two agree at the endpoints and nowhere between, so
+ * feeding this `w` to a froxel textureSample reads the wrong slab.
+ *
+ * @see volumetrics_position_world_to_froxel_uvw
+ * @type {CodeChunk}
+ */
+const chunk_volumetrics_froxel_coord_to_frustum_uvw = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_froxel_coord_to_frustum_uvw(
+    coord: vec3<u32>,
+    res: vec3<u32>,
+    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+    cluster_params: vec3f
+) -> vec3f {
+    let uv = texel_coordinate_to_uv(vec2f(coord.xy), res.xy);
+
+    // Logical near/far (clip_near_far), NOT the projection-derived range: the projection is
+    // infinite-far reverse-Z so its far resolves to ~3.4e38, which collapses z0_norm below to ~0
+    // (every slice maps to the near plane). This was the core reason TAA reprojection produced
+    // garbage. Matches the participating-media build shader.
+    let near_far = camera.clip_near_far;
+
+    // centre of the froxel along the depth curve
+    let depth_raw = cluster_depth_from_z_slice(
+        f32(coord.z) + 0.5,
+        cluster_params,
+        f32(res.z)
+    );
+
+    let view_depth = clamp(
+        depth_raw,
+        near_far.x,
+        near_far.y
+    );
+
+    let z0_norm = (view_depth - near_far.x) / (near_far.y - near_far.x);
+
+    return vec3f(uv, z0_norm);
+}
+    `, [
+        chunk_texel_coordinate_to_uv,
+        chunk_cluster_depth_from_z_slice,
+    ]
+);
+
+const chunk_world_pos_from_froxel = CodeChunk.from(
+    //language=WGSL
+    `
+// Helper to get world position from voxel index
+fn world_pos_from_froxel(
+    coord: vec3<u32>,
+    res: vec3<u32>,
+    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+    cluster_params: vec3f,
+    frustum: array<vec4<f32>, 6>
+) -> vec3f {
+    let uvw = volumetrics_froxel_coord_to_frustum_uvw(coord, res, camera, cluster_params);
+
+    // Reconstruct the froxel-centre world position. frustum_sample_point intersects the
+    // interpolated L/R, B/T, N/F planes; X maps left->left and Z maps near->far directly, so only
+    // screen-Y is flipped vs world-Y (1.0 - uvw.y). The caller passes the metadata frustum, which
+    // carries a FINITE far plane — the camera's own projection is infinite-far reverse-Z (far plane
+    // zeroed), which frustum_sample_point cannot intersect. Mirrors the participating-media build
+    // shader's Y-only flip; replaces the old vec3(1.0) - uvw inside-out hack that mirrored X and Z.
+    return frustum_sample_point(frustum, vec3f(uvw.x, 1.0 - uvw.y, uvw.z));
+}
+`, [
+        chunk_volumetrics_froxel_coord_to_frustum_uvw,
+        chunk_frustum_sample_point,
+    ]);
+
+/**
+ * Where this frame's froxel was in last frame's froxel grid, for the volumetric TAA.
+ *
+ * Reconstructs the froxel centre in world space through the current camera's metadata frustum,
+ * then projects it through the previous camera. Returns `(prev_uvw, prev_depth)`: the first three
+ * are the history texture coordinate, the last is planar view depth in the previous camera, which
+ * `volumetrics_taa_history_valid` needs because a point behind that camera still projects to a uv
+ * in range -- the divide by a negative `w` mirrors it into the frame.
+ *
+ * A pure function of its arguments so `chunk_volumetrics_taa_reproject.spec.js` can drive it in
+ * the WGSL emulator against geometry-derived expectations; it was inline in the TAA body before.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_taa_reproject = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_taa_reproject(
+    coord: vec3<u32>,
+    res: vec3<u32>,
+    camera_current: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+    camera_previous: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+    cluster_params: vec3f,
+    frustum: array<vec4<f32>, 6>
+) -> vec4f {
+    let position_ws = world_pos_from_froxel(coord, res, camera_current, cluster_params, frustum);
+
+    // Planar view depth in the previous camera: the metric the cluster curve is built in.
+    let prev_view = camera_previous.view_matrix * vec4f(position_ws, 1.0);
+    let prev_depth = -prev_view.z;
+
+    // NDC through the UN-jittered projection. GPUCameraContext bakes the TAA sub-pixel jitter into
+    // the projection it uploads as a shear in m[8]/m[9] and nowhere else, while the metadata
+    // frustum the reconstruction above went through comes from the CPU camera and carries none.
+    // Reprojecting through view_projection_matrix therefore moved a static camera by last frame's
+    // jitter, up to 0.03 froxel, every frame. projection_infinite_reverse_z has no other
+    // off-diagonal terms, so the un-jittered clip.xy is the diagonal times view xy, and clip.w is
+    // -view.z, which is prev_depth. WGSL indexes a matrix by column: P[0][0] is m[0], P[1][1] m[5].
+    let P = camera_previous.projection_matrix;
+    let prev_ndc = vec2f(P[0][0] * prev_view.x, P[1][1] * prev_view.y) / prev_depth;
+
+    let prev_uv = ndc_to_uv(prev_ndc);
+
+    let prev_slice = cluster_depth_to_z_slice(
+        prev_depth,
+        cluster_params,
+        f32(res.z)
+    );
+
+    // prev_slice already lands at the reconstructed froxel's CENTRE — the reconstruction sampled
+    // cluster_depth_from_z_slice(voxel.z + 0.5), so for a static camera prev_slice == voxel.z + 0.5,
+    // whose texel-centre normalized coord is exactly prev_slice / res.z. Adding a further +0.5 here
+    // double-counted the texel-centre offset and sampled half a froxel too far in Z every frame: the
+    // history blurred slice z into z+1 and the 0.95 blend fed that error back (the visible noise).
+    let prev_w = prev_slice / f32(res.z);
+
+    return vec4f(prev_uv, prev_w, prev_depth);
+}
+
+// Reprojection must land inside the volume, and history must not be flagged for reset (first
+// frame / resize / teleport); otherwise the TAA falls back to the fresh sample.
+fn volumetrics_taa_history_valid(reprojection: vec4f, history_reset: u32) -> bool {
+    let prev_uvw = reprojection.xyz;
+    let prev_depth = reprojection.w;
+
+    // A froxel behind the previous camera has a negative depth there, and the divide by that
+    // negative w mirrored its NDC, so the uv alone can land inside the frame and lie. The Z half
+    // of the range test cannot fail, cluster_depth_to_z_slice clamps to [0, limit]; it is the xy
+    // that the range test is for.
+    return prev_depth > 0.0
+        && all(prev_uvw >= vec3f(0.0))
+        && all(prev_uvw <= vec3f(1.0))
+        && history_reset == 0u;
+}
+    `, [
+        CAMERA_UNIFORM_STRUCT.declaration_chunk,
+        chunk_world_pos_from_froxel,
+        chunk_cluster_depth_to_z_slice,
+        chunk_ndc_to_uv,
+    ]
+);

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_resolve.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The volumetric TAA's resolve: clip the reprojected history to the neighbourhood box, then blend
+ * it with the current sample. Everything is in the encoded space the body works in, YCoCg for the
+ * scattering and the extinction as is.
+ *
+ * A pure function of the four vectors so `chunk_volumetrics_taa_resolve.spec.js` can drive it in
+ * the WGSL emulator; it was inline in the TAA body before.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_taa_resolve: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_volumetrics_taa_resolve.d.ts.map

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_volumetrics_taa_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_resolve.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,4CAFU,SAAS,CA2CjB;0BArDwB,oCAAoC"}

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_resolve.js

@@ -0,0 +1,56 @@
+import { chunk_color_clip_to_aabb4 } from "../../postprocess/taa/chunk_color_clip_to_aabb3.js";
+import { chunk_aabb4_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_aabb4_normalized_dist.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The volumetric TAA's resolve: clip the reprojected history to the neighbourhood box, then blend
+ * it with the current sample. Everything is in the encoded space the body works in, YCoCg for the
+ * scattering and the extinction as is.
+ *
+ * A pure function of the four vectors so `chunk_volumetrics_taa_resolve.spec.js` can drive it in
+ * the WGSL emulator; it was inline in the TAA body before.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_taa_resolve = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_taa_resolve(
+    center: vec4f,
+    history: vec4f,
+    aabb_min: vec4f,
+    aabb_max: vec4f
+) -> vec4f {
+    // The box contains the centre by construction (volumetric_history_bounding_box), which is what
+    // makes this a clip: the history moves toward the centre until it enters the box.
+    let history_clamped = color_clip_to_aabb4(history, center, aabb_min, aabb_max);
+
+    // Karis, "High Quality Temporal Supersampling", SIGGRAPH 2014: detect when a clamp would occur
+    // and dampen the INCOMING sample's contribution to counteract it. The current sample is a 1-spp
+    // point sample of the froxel, so a jitter landing on a thin lit feature is an ordinary frame;
+    // without the damping that impulse moves the resolve by its full weight and the next frame's
+    // clip takes it back, which reads as flicker. t_clamp is 1 whenever the clip moved the
+    // history, and falls toward 0 as the history sits nearer the centre.
+    let t_clamp = saturate(aabb4_normalized_dist_from_center(
+        center,
+        history_clamped,
+        aabb_min,
+        aabb_max,
+    ));
+
+    // The 0.95 feedback the rest of the subsystem is tuned around (~39 effective samples). This
+    // used to damp the HISTORY by (1 - t^3), which is the rule backwards: any clipped voxel then
+    // output the raw sample, and under motion that was most of them. The quarter is a tuning
+    // value; what is fixed is the direction -- the damping can only lower the sample's pull.
+    const W_CURRENT = 0.05;
+    const W_CURRENT_CLAMPED = W_CURRENT * 0.25;
+
+    let w_current = mix(W_CURRENT, W_CURRENT_CLAMPED, t_clamp * t_clamp);
+
+    return mix(history_clamped, center, w_current);
+}
+    `, [
+        chunk_color_clip_to_aabb4,
+        chunk_aabb4_normalized_dist,
+    ]
+);

package/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js"],"names":[],"mappings":"AA0UA,mDAIG;8BApU2B,+BAA+B"}
+{"version":3,"file":"shader_volumetrics_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js"],"names":[],"mappings":"AAkIA,mDAIG;8BAlI2B,+BAA+B"}