@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/postprocess/nss/shader_nss_preprocess.js

@@ -213,6 +213,19 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     textureStore(tTensor, vec3<i32>(st, 2), vec4<f32>(feedback_q.gba, luma_deriv_q));
 
     // Pack nearest offset for postprocess: (-1, 0, 1) in each axis -> [0, 1]
+    //
+    // NOTE there are two offset codecs in flight per frame under NSS. This packs (offset + 1) * 0.5
+    // into the rg of its own rg8unorm texture and shader_nss_postprocess decodes it inline; the TAA
+    // depth-clip pass, which runs unconditionally and whose confidence output NSS consumes, packs
+    // index/8 into one channel of its own output through chunk_depth_clip_offset_codec, which has a
+    // round-trip spec. The 9-tap search itself is now shared (chunk_find_nearest_depth), so the two
+    // agree on what they are encoding — but the search still runs twice over the same depth buffer and
+    // a reader has to check which convention a given rg8unorm offset texture uses.
+    //
+    // Collapsing them means this pass reading the depth-clip g channel instead of writing
+    // tNearestOffset, which changes what NSS is bound to and what its postprocess pair decodes. That is
+    // a pipeline change with a visual outcome rather than a de-duplication, so it wants a measured
+    // before/after on hardware; left as is deliberately. See DUP-039.
     let nearest_packed = (vec2<f32>(nearest_off) + 1.0) * 0.5;
     textureStore(tNearestOffset, st, vec4<f32>(nearest_packed, 0.0, 0.0));
 }

package/src/shade/renderer/postprocess/ssr/SSR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IAyDI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA3DD,oBAAgB;IAMhB,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IA0B3E,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAbnD,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAA;KAAC,CAkQhG;;CACJ;0CAzYyC,oCAAoC"}
+{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IAyDI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA3DD,oBAAgB;IAMhB,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IA0B3E,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAbnD,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAA;KAAC,CAoQhG;;CACJ;0CA3YyC,oCAAoC"}

package/src/shade/renderer/postprocess/ssr/SSR.js

@@ -80,8 +80,8 @@ export class SSR {
 
         for (const [history, format, label] of [
             [this.#history, "rgba16float", "radiance"],
-            // xy: reflected distance/support, z: history age, w: short-term luminance.
-            [this.#metadata, "rgba32float", "metadata"],
+            // xy: reflected distance/support, z: history age, w: short-term luminance.
+            [this.#metadata, "rgba32float", "metadata"],
             [this.#geometry, "rgba16float", "geometry"],
         ]) {
             for (let i = 0; i < 2; i++) {
@@ -127,7 +127,7 @@ export class SSR {
      * @param {number} options.camera_current
      * @param {number} options.camera_previous
      * @param {ShadeIndirectLightingMode} [options.indirect_lighting_mode] Explicit GI fallback selection
-     * @param {import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4]
+     * @param {import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4]
      * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv]
      * @param {import("../../view/GPUViewContext.js").GPUViewContext} [options.view_ctx]
      * @param {ArrayLike<number>} [options.jitter] Raster jitter in internal pixels
@@ -167,9 +167,9 @@ export class SSR {
                 gi_inputs = { tEnvironment: input_environment };
                 break;
             case ShadeIndirectLightingMode.Brick4:
-                assert.defined(brick4, 'SSR Brick4 lightmap');
+                assert.defined(brick4, 'SSR Brick4 lightmap');
                 resolve_shader = ssr_resolve_shader_Brick4;
-                gi_inputs = { brick4: brick4.buffer, tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2 };
+                gi_inputs = { brick4: brick4.buffer, tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2 };
                 break;
             case ShadeIndirectLightingMode.LPV:
                 assert.defined(lpv, 'SSR LPV');
@@ -246,7 +246,9 @@ export class SSR {
                 tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
                 settings: {
                     max_distance: 16.0,
-                    edge_fade: 0.07,
+                    // 0.05 is what the vignette used to hard-code, so wiring the setting in leaves the
+            // picture exactly where it was; 0.07 was never applied to anything.
+            edge_fade: 0.05,
                     frame_index,
                 },
                 camera: camera_current
@@ -391,4 +393,4 @@ export class SSR {
             reflections,
         };
     }
-}
+}

package/src/shade/renderer/postprocess/ssr/depth_max_shader.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Inclusive source-texel window one output texel of the reduction reads: `(min.xy, max.xy)`.
+ *
+ * The windows of one step tile the source exactly — every source texel belongs to one output texel,
+ * none twice and none missed — which is what makes the result a max over the whole level rather than a
+ * max over an arbitrary stencil. Pinned by `depth_max_source_bounds.spec`.
+ *
+ * The stride is `ceil(source / output)`, not a hardcoded 2, and the upper bound is
+ * `min + stride - 1` because the loops that read it are inclusive. It used to be `target * 2` for the
+ * origin and `min + stride` for the bound, which at a halving step is three texels per axis: nine
+ * reads for a 2x2 footprint, overlapping its neighbours on both sides.
+ */
+export const chunk_depth_max_source_bounds: CodeChunk;
 export const depth_max_shader: ImageShader;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=depth_max_shader.d.ts.map

package/src/shade/renderer/postprocess/ssr/depth_max_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"depth_max_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/depth_max_shader.js"],"names":[],"mappings":"AAyDA,2CAWG;4BAnEyB,6BAA6B"}
+{"version":3,"file":"depth_max_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/depth_max_shader.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;GAWG;AACH,sDAyBE;AAkCF,2CAWG;0BAhGuB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/postprocess/ssr/depth_max_shader.js

@@ -11,6 +11,46 @@ resources.setImmediate("output_resolution", "vec2<u32>");
 resources.createGroup()
     .addTexture("tInput");
 
+
+/**
+ * Inclusive source-texel window one output texel of the reduction reads: `(min.xy, max.xy)`.
+ *
+ * The windows of one step tile the source exactly — every source texel belongs to one output texel,
+ * none twice and none missed — which is what makes the result a max over the whole level rather than a
+ * max over an arbitrary stencil. Pinned by `depth_max_source_bounds.spec`.
+ *
+ * The stride is `ceil(source / output)`, not a hardcoded 2, and the upper bound is
+ * `min + stride - 1` because the loops that read it are inclusive. It used to be `target * 2` for the
+ * origin and `min + stride` for the bound, which at a halving step is three texels per axis: nine
+ * reads for a 2x2 footprint, overlapping its neighbours on both sides.
+ */
+export const chunk_depth_max_source_bounds = CodeChunk.from(
+    //language=WGSL
+    `
+fn depth_max_source_bounds(
+    target_coord: vec2<u32>,
+    source_resolution: vec2<u32>,
+    output_resolution: vec2<u32>
+) -> vec4<u32> {
+
+    let scale = vec2f(source_resolution) / vec2f(output_resolution);
+
+    let stride = max(vec2u(ceil(scale)), vec2u(1u));
+
+    let source_bounds_min = target_coord * stride;
+
+    // inclusive, and clamped so an output resolution that does not divide the source cannot read past
+    // the last texel
+    let source_bounds_max = min(
+        source_bounds_min + stride - vec2u(1u),
+        source_resolution - vec2u(1u)
+    );
+
+    return vec4u(source_bounds_min, source_bounds_max);
+}
+    `
+);
+
 const body = CodeChunk.from(
     //language=WGSL
     `
@@ -19,40 +59,28 @@ fn main(
     @builtin(position) coord : vec4<f32>,
     @location(0) uv: vec2<f32>,
 ) -> @location(0) f32 {
-    
-    
+
     let target_coord_i = vec2<u32>(coord.xy);
-                
+
     let source_resolution = textureDimensions(tInput);
-    
-    let scale = vec2f(source_resolution) / vec2f(output_resolution);
-    
-    let scale_i = vec2u(ceil(scale));
-    
-    let source_coord_i = target_coord_i * 2;
-                        
-    // compute bounds in source texture
-    let source_bounds_max =  min(
-        source_coord_i + scale_i,
-        source_resolution - 1
-    );
-    
-    let source_bounds_min = source_coord_i;
-    
+
+    let bounds = depth_max_source_bounds(target_coord_i, source_resolution, output_resolution);
+
     var max_value = 0.0;
-    
-    for(var y = source_bounds_min.y ; y <= source_bounds_max.y ; y++){
-        for(var x = source_bounds_min.x ; x<= source_bounds_max.x ; x++){
-        
+
+    for(var y = bounds.y ; y <= bounds.w ; y++){
+        for(var x = bounds.x ; x <= bounds.z ; x++){
+
             let depth = textureLoad(tInput, vec2u(x,y), 0).r;
-            
+
             max_value = max(depth, max_value);
         }
     }
-    
+
     return max_value;
 }
-    `
+    `,
+    [chunk_depth_max_source_bounds]
 )
 
 export const depth_max_shader = new ImageShader({

package/src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.d.ts

@@ -1,5 +1,15 @@
 /**
- * NOTE: Generally HZB should be sufficient instead of this, see {@link HierarchicalZBuffer}
+ * Build an `r32float` max-depth mip chain.
+ *
+ * **Nothing calls this.** `SSR.graph_pass` binds `view_ctx.hierarchical_z_buffer.texture` as
+ * `tHZB` — see `Renderer.js` — and {@link HierarchicalZBuffer} is generally sufficient instead of
+ * this. Kept because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is still
+ * public surface.
+ *
+ * **The two are not interchangeable.** This pyramid is single-channel; the live HZB is two-channel and
+ * `chunk_ffx_sssr_load_depth` reads its `.y`. Substituting this one gives a silently zero `.y`
+ * rather than an error. See `prefilter/NOTES.md` for the rest of the dead surface in this directory.
+ *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {number[]} options.resolution

package/src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_build_depth_max_pyramid.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH;IAJ+B,KAAK;IACP,UAAU,EAA5B,MAAM,EAAE;IACQ,WAAW,EAA3B,MAAM;QAiGhB"}
+{"version":3,"file":"graph_build_depth_max_pyramid.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH;IAJ+B,KAAK;IACP,UAAU,EAA5B,MAAM,EAAE;IACQ,WAAW,EAA3B,MAAM;QAiGhB"}

package/src/shade/renderer/postprocess/ssr/graph_build_depth_max_pyramid.js

@@ -4,7 +4,17 @@ import { copy_shader_f32 } from "./copy_shader_f32.js";
 import { depth_max_shader } from "./depth_max_shader.js";
 
 /**
- * NOTE: Generally HZB should be sufficient instead of this, see {@link HierarchicalZBuffer}
+ * Build an `r32float` max-depth mip chain.
+ *
+ * **Nothing calls this.** `SSR.graph_pass` binds `view_ctx.hierarchical_z_buffer.texture` as
+ * `tHZB` — see `Renderer.js` — and {@link HierarchicalZBuffer} is generally sufficient instead of
+ * this. Kept because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is still
+ * public surface.
+ *
+ * **The two are not interchangeable.** This pyramid is single-channel; the live HZB is two-channel and
+ * `chunk_ffx_sssr_load_depth` reads its `.y`. Substituting this one gives a silently zero `.y`
+ * rather than an error. See `prefilter/NOTES.md` for the rest of the dead surface in this directory.
+ *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {number[]} options.resolution

package/src/shade/renderer/postprocess/ssr/prefilter/NOTES.md

@@ -0,0 +1,46 @@
+# `ssr/prefilter/` — what is live in here and what is not
+
+This directory is a port of AMD's FFX DNSR reflections denoiser. **It is not the denoiser the SSR
+pipeline runs.** Two files in it are, and the other ten are not, which is worth stating because a
+directory that the live path imports from reads as a dependency of the live path.
+
+## Live
+
+`ssr_spatial_denoise_shader.js`, one directory up, is the denoiser `SSR.graph_pass` builds. It is an
+à-trous filter, not FFX's, and it reaches in here for exactly two chunks:
+
+- `chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight`
+- `chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight`
+
+Those two are the edge-stopping weights, which are shared between the two denoisers because the
+weight function is the same question either way.
+
+## Not live
+
+Everything else:
+
+- `shader_ssr_prefilter.js` — the compute pass
+- `chunk_ffx_dnsr_reflections_prefilter.js`, `chunk_ffx_dnsr_reflections_resolve.js`
+- `chunk_ffx_dnsr_reflections_get_radiance_weight.js`
+- `NEIGHBOURHOOD_SAMPLE.js`, `chunk_load_neighbourhood_sample.js`
+- the four LDS tiling chunks: `chunk_ffx_dnsr_group_shared_memory`,
+  `chunk_initialize_group_shared_memory`, `chunk_load_from_group_shared_memory`,
+  `chunk_store_in_group_shared_memory`
+
+A grep for any of those symbols outside this directory returns nothing. They are kept because
+`@woosh/meep-engine` publishes raw `src`, so an unreferenced export is still public surface — not
+because anything schedules them.
+
+## If the FFX path is ever revived
+
+It has drifted against the live pipeline in one way that a reader will not notice from inside this
+directory: the à-trous path grew `chunk_ssr_metadata`, and the variance/metadata contract the
+prefilter expects predates it. Reconcile those before wiring the pass in, rather than after.
+
+## Sibling trap, same territory
+
+`graph_build_depth_max_pyramid.js` (also one directory up, also unreferenced) builds a
+**single-channel `r32float`** max-depth chain, while the live `HierarchicalZBuffer` the SSR trace
+actually reads is **two-channel** — `chunk_ffx_sssr_load_depth` reads its `.y`. The two are not
+interchangeable, and swapping one in for the other gives a silently zero `.y` rather than an error.
+That file's own header says the same thing.

package/src/shade/renderer/postprocess/ssr/prefilter/shader_ssr_prefilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_ssr_prefilter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/prefilter/shader_ssr_prefilter.js"],"names":[],"mappings":"AA+DA,iDAII;8BA/D0B,kCAAkC"}
+{"version":3,"file":"shader_ssr_prefilter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/prefilter/shader_ssr_prefilter.js"],"names":[],"mappings":"AAsEA,iDAII;8BAtE0B,kCAAkC"}

package/src/shade/renderer/postprocess/ssr/prefilter/shader_ssr_prefilter.js

@@ -7,6 +7,13 @@ import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderReso
 import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
 import { chunk_ffx_dnsr_reflections_prefilter } from "./chunk_ffx_dnsr_reflections_prefilter.js";
 
+/*
+ * The FFX DNSR reflections prefilter pass. Nothing schedules it — the live denoiser is the à-trous
+ * `ssr_spatial_denoise_shader` one directory up, which borrows only the two edge-stopping weight
+ * chunks from here. See NOTES.md in this directory for what is live, what is not, and what has drifted
+ * since.
+ */
+
 const resources = new ShaderResourceSetDescriptor();
 
 /**

package/src/shade/renderer/postprocess/ssr/shader/chunk_ssr_depth_thickness.d.ts

@@ -0,0 +1,32 @@
+/**
+ * How much wider the thickness test gets at the roughest ray SSR will trace, as a multiple of the
+ * base thickness.
+ *
+ * The term used to be `roughness * 10` added OUTRIGHT — view-space units, not a multiple — so at the
+ * 0.3 roughness cutoff it contributed 3.0 against a base of 0.1, and against FidelityFX's own
+ * documented default of 0.015. At those magnitudes the test stops being a thickness test: a hit a
+ * metre behind a railing scored `(1 - smoothstep(0, 3.1, 1.0))²` = 0.57 confidence and the wall
+ * behind it was composited in at 57% as if the ray had struck the railing. Only a hit deeper than
+ * about three metres behind geometry was rejected at all. That is the reflections-smear-behind-
+ * thin-geometry artifact, across the whole roughness range SSR runs on, and it feeds the temporal
+ * history — which validates geometry, not rays, so it cannot tell a false hit from a true one.
+ *
+ * Widening with roughness is deliberate and kept: a rough ray's hit is genuinely less precise. It is
+ * a multiple of the base now, so the base is what sets the scale, which is what "thickness" is for.
+ *
+ * @type {number}
+ */
+export const SSR_ROUGHNESS_THICKNESS_GAIN: number;
+/**
+ * Widening with distance, per view-space unit of ray travelled.
+ * @type {number}
+ */
+export const SSR_THICKNESS_LENGTH_FACTOR: number;
+/**
+ * How far below the depth buffer's surface a hit may sit and still be believed.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_depth_thickness: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ssr_depth_thickness.d.ts.map

package/src/shade/renderer/postprocess/ssr/shader/chunk_ssr_depth_thickness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_depth_thickness.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/shader/chunk_ssr_depth_thickness.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,0CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,wCAFU,SAAS,CAShB;0BAxCuB,uCAAuC"}

package/src/shade/renderer/postprocess/ssr/shader/chunk_ssr_depth_thickness.js

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * How much wider the thickness test gets at the roughest ray SSR will trace, as a multiple of the
+ * base thickness.
+ *
+ * The term used to be `roughness * 10` added OUTRIGHT — view-space units, not a multiple — so at the
+ * 0.3 roughness cutoff it contributed 3.0 against a base of 0.1, and against FidelityFX's own
+ * documented default of 0.015. At those magnitudes the test stops being a thickness test: a hit a
+ * metre behind a railing scored `(1 - smoothstep(0, 3.1, 1.0))²` = 0.57 confidence and the wall
+ * behind it was composited in at 57% as if the ray had struck the railing. Only a hit deeper than
+ * about three metres behind geometry was rejected at all. That is the reflections-smear-behind-
+ * thin-geometry artifact, across the whole roughness range SSR runs on, and it feeds the temporal
+ * history — which validates geometry, not rays, so it cannot tell a false hit from a true one.
+ *
+ * Widening with roughness is deliberate and kept: a rough ray's hit is genuinely less precise. It is
+ * a multiple of the base now, so the base is what sets the scale, which is what "thickness" is for.
+ *
+ * @type {number}
+ */
+export const SSR_ROUGHNESS_THICKNESS_GAIN = 10;
+
+/**
+ * Widening with distance, per view-space unit of ray travelled.
+ * @type {number}
+ */
+export const SSR_THICKNESS_LENGTH_FACTOR = 0.01;
+
+/**
+ * How far below the depth buffer's surface a hit may sit and still be believed.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_depth_thickness = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_depth_thickness(base: f32, roughness: f32, view_ray_length: f32) -> f32 {
+    return base * (1.0 + roughness * ${SSR_ROUGHNESS_THICKNESS_GAIN}f)
+        + view_ray_length * ${SSR_THICKNESS_LENGTH_FACTOR}f;
+}
+`);

package/src/shade/renderer/postprocess/ssr/ssr_trace_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_trace_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_trace_shader.js"],"names":[],"mappings":"AA4BA,mDAcG;AA+JH,2CAYG;6BApN0B,mCAAmC;4BAkBpC,6BAA6B"}
+{"version":3,"file":"ssr_trace_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_trace_shader.js"],"names":[],"mappings":"AA6BA,mDAcG;AAmKH,2CAYG;6BAzN0B,mCAAmC;4BAkBpC,6BAA6B"}

package/src/shade/renderer/postprocess/ssr/ssr_trace_shader.js

@@ -24,6 +24,7 @@ import { chunk_ssr_hit_pack } from "./chunk_ssr_hit_pack.js";
 import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
 import { chunk_is_glossy_reflection } from "./shader/chunk_is_glossy_reflection.js";
 import { chunk_is_mirror_reflection } from "./shader/chunk_is_mirror_reflection.js";
+import { chunk_ssr_depth_thickness } from "./shader/chunk_ssr_depth_thickness.js";
 import { SSR_RAY_HIT } from "./SSR_RAY_HIT.js";
 
 export const SETTINGS_UNIFORM_STRUCT = WebGPUStruct.from({
@@ -82,7 +83,6 @@ const INVALID_RESULT_VALUE = vec2u(0);
 
 const g_most_detailed_mip = 0;
 const g_depth_buffer_thickness = ${SSR_DEPTH_BUFFER_THICKNESS};
-const g_thickness_length_factor = 0.01f;
 
 @fragment
 fn main(
@@ -159,12 +159,15 @@ fn main(
     let view_space_hit      = ffx_sssr_screen_space_to_view_space(hit);
     let view_space_ray_      = view_space_hit - view_space_ray.xyz;
     let view_ray_length     = length(view_space_ray_);
+
+    // How far the effect is configured to trace. The march's only bounds were the traversal cap and
+    // the viewport, so a glossy floor down a long corridor picked up radiance from a surface well
+    // past this and composited it at full strength — and tuning the setting changed nothing at all.
+    if (view_ray_length > settings.max_distance) {
+        return INVALID_RESULT_VALUE;
+    }
     
-    let depth_thickness = g_depth_buffer_thickness 
-        // Add thickness for rough surfaces
-        + roughness*10 
-        // Add thickness with distance
-        + view_ray_length*g_thickness_length_factor;
+    let depth_thickness = ssr_depth_thickness(g_depth_buffer_thickness, roughness, view_ray_length);
     
     var view_ray_direction = normalize(view_space_ray_);
 
@@ -174,6 +177,7 @@ fn main(
         view_ray_direction,
         vec2<f32>(screen_size),
         depth_thickness,
+        settings.edge_fade,
     );
     
     // pack hit
@@ -187,6 +191,7 @@ fn main(
         chunk_stbn_sample_vec2,
         chunk_ffx_sssr_hierarchical_raymarch,
         chunk_is_mirror_reflection,
+        chunk_ssr_depth_thickness,
         chunk_ffx_sssr_load_world_space_normal,
         chunk_ffx_sssr_screen_space_to_view_space,
         chunk_project_direction,

package/src/shade/renderer/postprocess/taa/TAA.d.ts

@@ -1,6 +1,4 @@
 export class TAA {
-    Jitter: number[];
-    JitterDelta: number[];
     /**
      * When set, will disregard history buffer
      * Useful for camera cuts and large scene changes such as scene load
@@ -8,13 +6,24 @@ export class TAA {
      */
     reset_history: boolean;
     /**
-     *
+     * Offset for the current frame, in pixels.
+     * @returns {number[]}
+     */
+    get Jitter(): number[];
+    /**
+     * Frame-to-frame delta of {@link Jitter}.
+     * @returns {number[]}
+     */
+    get JitterDelta(): number[];
+    /**
      * @param {number} size
      */
     set jitter_sequence_size(size: number);
+    /**
+     * @returns {number}
+     */
     get jitter_sequence_size(): number;
     /**
-     *
      * @param {number} i
      */
     set frame_index(i: number);

package/src/shade/renderer/postprocess/taa/TAA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAQA;IAEI,iBAAgB;IAChB,sBAAqB;IAErB;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA0BtB;;;OAGG;IACH,uCAIC;IAED,mCAEC;IAED;;;OAGG;IACH,2BAmBC;IAED;;;;;;;;;;OAUG;IACH;QAR+B,KAAK;QACT,gBAAgB,EAAhC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,iBAAiB,EAAjC,MAAM;eAkChB;;CACJ"}
+{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAOA;IAEI;;;;OAIG;IACH,eAFU,OAAO,CAEK;IAatB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;OAEG;IACH,uCAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;;;;;OAUG;IACH;QAR+B,KAAK;QACT,gBAAgB,EAAhC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,iBAAiB,EAAjC,MAAM;eAkChB;;CACJ"}

package/src/shade/renderer/postprocess/taa/TAA.js

@@ -1,16 +1,12 @@
 //
 
 
-import { assert } from "../../../../core/assert.js";
-import { halton_sequence } from "../../../../core/math/statistics/halton_sequence.js";
+import { TemporalJitterSequence } from "../TemporalJitterSequence.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { shader_taa } from "./shader_taa.js";
 
 export class TAA {
 
-    Jitter = [0, 0];
-    JitterDelta = [0, 0];
-
     /**
      * When set, will disregard history buffer
      * Useful for camera cuts and large scene changes such as scene load
@@ -18,67 +14,52 @@ export class TAA {
      */
     reset_history = false;
 
-    #jitter_sequence = new Float64Array(32);
-    #jitter_sequence_size = 16;
+    /**
+     * Sixteen Halton phases by default; `Renderer` scales that with the resolution.
+     *
+     * NSS composes one of these too. The two classes used to carry a line-for-line copy of the sequence,
+     * the two offset arrays and the frame_index setter each, which is why `Renderer` can pick either
+     * object as "the jitter source" — the call site already treated them as one interface.
+     *
+     * @type {TemporalJitterSequence}
+     */
+    #jitter = new TemporalJitterSequence(16);
 
-    constructor() {
-        this.#update_jitter_sequence();
+    /**
+     * Offset for the current frame, in pixels.
+     * @returns {number[]}
+     */
+    get Jitter() {
+        return this.#jitter.Jitter;
     }
 
-    #update_jitter_sequence() {
-
-        const sample_count = this.#jitter_sequence_size;
-
-        const sequence = new Float64Array(sample_count * 2);
-
-        for (let i = 0; i < sample_count; i++) {
-
-            // Note the +1, this avoids the 0 sample which is trash
-            sequence[i * 2] = halton_sequence(2, i + 1) - 0.5;
-            sequence[i * 2 + 1] = halton_sequence(3, i + 1) - 0.5;
-        }
-
-        this.#jitter_sequence = sequence;
-
+    /**
+     * Frame-to-frame delta of {@link Jitter}.
+     * @returns {number[]}
+     */
+    get JitterDelta() {
+        return this.#jitter.JitterDelta;
     }
 
     /**
-     *
      * @param {number} size
      */
     set jitter_sequence_size(size) {
-        assert.isNonNegativeInteger(size, 'size');
-        this.#jitter_sequence_size = size;
-        this.#update_jitter_sequence();
+        this.#jitter.size = size;
     }
 
+    /**
+     * @returns {number}
+     */
     get jitter_sequence_size() {
-        return this.#jitter_sequence_size;
+        return this.#jitter.size;
     }
 
     /**
-     *
      * @param {number} i
      */
     set frame_index(i) {
-        assert.isNonNegativeInteger(i, 'i');
-
-        const wrapped_index = i % this.#jitter_sequence_size;
-
-        const address = wrapped_index * 2;
-
-        const offset_x = this.#jitter_sequence[address];
-        const offset_y = this.#jitter_sequence[address + 1];
-
-        assert.isNumber(offset_x, 'offset_x');
-        assert.isNumber(offset_y, 'offset_y');
-
-        // see https://github.com/GameTechDev/TAA/blob/39786709cf70a1e0906196c600f6079571a33ceb/MiniEngine/Core/TemporalEffects.cpp#L187
-        this.JitterDelta[0] = this.Jitter[0] - offset_x;
-        this.JitterDelta[1] = this.Jitter[1] - offset_y;
-
-        this.Jitter[0] = offset_x;
-        this.Jitter[1] = offset_y;
+        this.#jitter.frame_index = i;
     }
 
     /**

package/src/shade/renderer/postprocess/taa/chunk_taa_tonemap.d.ts

@@ -1,5 +1,16 @@
 /**
  * Slide 20 of "High Quality Temporal Supersampling" by Brian Karis at SIGGRAPH 2014.
+ *
+ * The guard on the way in is a FINITE clamp, not just a non-negative one, because the colour target
+ * is `rgba16float` and a shading result above its range stores as `+Inf` — a bright emissive, a
+ * specular lobe with a small denominator, a light with a large intensity. `rgb / (1 + luma)` is then
+ * `Inf / Inf`, which is NaN, and `rgb_to_YCoCg` spreads it across all three channels.
+ *
+ * That matters here more than it would anywhere else: the result is written to the next frame's
+ * history, and the resolve picks the valid-history branch on velocity, occlusion and screen bounds
+ * and never on the colour, so `mix(current, NaN, weight)` reproduces the NaN every frame. One frame
+ * of overbright shading leaves a pixel no camera motion clears, and a Catmull-Rom tap then spreads
+ * it into a blot.
  */
 export const chunk_taa_tonemap: CodeChunk;
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";

package/src/shade/renderer/postprocess/taa/chunk_taa_tonemap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_taa_tonemap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_tonemap.js"],"names":[],"mappings":"AAGA;;GAEG;AACH,0CAWE;0BAhBwB,oCAAoC"}
+{"version":3,"file":"chunk_taa_tonemap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_tonemap.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH,0CAeE;0BArCwB,oCAAoC"}