@woosh/meep-engine 3.11.3 → 3.13.0

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

@@ -1,231 +1,230 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { chunk_nss_find_nearest_depth } from "./chunk_nss_find_nearest_depth.js";
-import { chunk_nss_luma_derivative } from "./chunk_nss_luma_derivative.js";
-import { NSS_WORKGROUP_SIZE } from "./NSS_CONSTANTS.js";
-import { NSS_SETTINGS_STRUCT } from "./NSS_SETTINGS_STRUCT.js";
-
-/**
- * NSS preprocess pass. Runs at render-resolution (one thread per render-res
- * pixel) and produces:
- *  1. The 12-channel network input tensor, packed into a single rgba16f
- *     3D storage texture with depth=3 (channels 0..3, 4..7, 8..11).
- *  2. The encoded "nearest depth offset" used by postprocess to dilate
- *     velocity at output-res (`tNearestOffset` — components in [0, 1]
- *     decode to {-1, 0, 1}² via `(x*2 - 1)`).
- *
- * Per-pixel logic (matches the algorithm in ARM's `Preprocess()`):
- *   1. Dilate depth over a 3×3 neighbourhood, remember the offset of the
- *      nearest sample.
- *   2. Sample velocity at the dilated coord.
- *   3. Project to the previous frame, sample warped history (bilinear).
- *   4. Read the FSR2 depth-clip confidence from the upstream pass and
- *      invert it into the network's "high = disocclusion" convention.
- *   5. Sample the warped feedback tensor (bilinear).
- *   6. Compute the luma derivative between current and warped history.
- *   7. Pack everything into the output tensor — colours
- *      tonemapped via `Tonemap(EXPOSURE * raw)` to match ARM's training
- *      distribution.
- *
- * @see ARM NSS reference: `Preprocess` in
- *      `Source/NG-SDK/sdk/include/FidelityFX/gpu/nss/ffx_nss_preprocess.h`
- */
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
-    // ── inputs at render-res ──
-    .addTexture("tColour", "float")                          // jittered scene colour, render-res
-    // depth32float can't be bound as 'float' (filterable) — WebGPU only
-    // accepts depth textures via 'unfilterable-float' in this context.
-    // We only ever read this via textureLoad inside the depth dilation.
-    .addTexture("tDepthCurrent", "unfilterable-float")
-    .addTexture("tVelocity", "float")                        // pixel-space motion vectors, render-res
-    // FSR2 depth-clip confidence (1 = trust history, 0 = disocclusion)
-    // produced by the engine's shared shader_depth_occlusion_clip pass.
-    // We invert it into ARM's "high = disocclusion" network input.
-    .addTexture("tDisocclusionConfidence", "float")
-    // ── inputs at output-res / feedback at render-res ──
-    .addTexture("tHistory", "float")       // previous frame upscaled colour, output-res
-    .addTexture("tFeedbackIn", "float")    // 4-ch feedback tensor from previous frame, render-res
-    // ── settings ──
-    .addUniform("settings", NSS_SETTINGS_STRUCT)
-    // ── outputs ──
-    // Single rgba16f 3D storage texture holds the 12-channel input tensor
-    // packed across depth=3 layers (4 channels each). rgba16f gives the
-    // network ~10 bits of mantissa per channel, which is plenty for
-    // normalized [0, 1] inputs after the network's first BN/scale.
-    .addStorageTexture("tTensor", "rgba16float", "3d", "write-only")
-    // Nearest-depth offset packed as (dx+1, dy+1) / 2 -> [0, 1]. Postprocess
-    // uses this to fetch the velocity at the dilated coordinate when warping
-    // the history at output-resolution.
-    .addStorageTexture("tNearestOffset", "rg8unorm", "2d", "write-only")
-;
-
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const NSS_EXPOSURE: f32 = 7.38905609893; // e^2 — matches ARM's NSSCommon.ush
-
-// Karis tonemap (max-of-channels), applied to EXPOSURE-scaled colour.
-// ARM's training distribution: Tonemap(EXPOSURE * raw) -> network input.
-fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32> {
-    let scaled = rgb * NSS_EXPOSURE;
-    let m = max(max(scaled.r, scaled.g), scaled.b);
-    return scaled / (1.0 + m);
-}
-
-// ARM's network was trained against inputs that go through their Quantize
-// formula: int8 = round(fp * 255 - 128). The conv then sees (uint8 - 128)
-// = signed int8 in [-128, 127] - i.e. fp 0 -> -128, fp 0.5 -> 0, fp 1 -> 127.
-// Our pipeline naively feeds fp [0, 1] which has DC offset +0.5 vs ARM's
-// expected DC of 0. The trained head biases were calibrated against that
-// near-zero DC, so feeding +0.5 puts every conv accumulator off by
-// (sum_of_weights * 0.5 * 255) - way outside the trained operating range.
-//
-// We use the SMOOTH (no-round) version of ARM's transform: a linear
-// remap [0, 1] -> approx [-1.008, 1.008] clamped to [-1, 1]. Matches
-// ARM's DC shift but without the round() discontinuities that caused
-// feature-dependent flickering when small jitter-driven input changes
-// pushed pixels across quantization boundaries. Network sensitivity to
-// near-boundary inputs would otherwise flip int8 outputs by 1/127 per
-// frame and propagate through every layer.
-//
-// Per-multiply lands at ~(ARM signed * int8_w) / 127^2, so our acc is
-// approx (ARM int32_acc / 127^2). Our rescale_factor (= 127 * mult /
-// 2^shift) then produces value_fp ~ int8_in / 127 going into the LUT -
-// the shape ARM's network was trained to produce.
-fn nss_arm_quantize(fp: f32) -> f32 {
-    return clamp(fp * (255.0 / 127.0) - (128.0 / 127.0), -1.0, 1.0);
-}
-
-fn nss_arm_quantize_v3(rgb: vec3<f32>) -> vec3<f32> {
-    return vec3<f32>(nss_arm_quantize(rgb.r), nss_arm_quantize(rgb.g), nss_arm_quantize(rgb.b));
-}
-
-fn nss_arm_quantize_v4(v: vec4<f32>) -> vec4<f32> {
-    return vec4<f32>(nss_arm_quantize(v.x), nss_arm_quantize(v.y), nss_arm_quantize(v.z), nss_arm_quantize(v.w));
-}
-
-fn nss_warp_history_sample(prev_uv: vec2<f32>) -> vec3<f32> {
-    let on_screen = all(prev_uv >= vec2<f32>(0.0)) && all(prev_uv <= vec2<f32>(1.0));
-    if (!on_screen) {
-        return vec3<f32>(0.0);
-    }
-    // ARM uses bilinear (LoadHistory in ffx_nss_callbacks_glsl.h:471);
-    // Catmull-Rom is opt-in via HISTORY_CATMULL define.
-    return max(vec3<f32>(0.0), textureSampleLevel(tHistory, sLinear, prev_uv, 0.0).rgb);
-}
-
-fn nss_warp_feedback_sample(prev_uv_render: vec2<f32>) -> vec4<f32> {
-    let on_screen = all(prev_uv_render >= vec2<f32>(0.0)) && all(prev_uv_render <= vec2<f32>(1.0));
-    if (!on_screen) {
-        return vec4<f32>(0.0);
-    }
-    return textureSampleLevel(tFeedbackIn, sLinear, prev_uv_render, 0.0);
-}
-
-@compute @workgroup_size(${NSS_WORKGROUP_SIZE}, ${NSS_WORKGROUP_SIZE}, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let render_res_u = settings.render_resolution;
-    let render_res = vec2<i32>(render_res_u);
-
-    if (any(gid.xy >= render_res_u)) {
-        return;
-    }
-
-    let st = vec2<i32>(gid.xy);
-
-    // 1. Depth dilation
-    var nearest_off = vec2<i32>(0, 0);
-    let _dilated_depth = nss_find_nearest_depth(tDepthCurrent, st, render_res, &nearest_off);
-
-    // 2. Velocity at the depth-nearest tap (FSR2 strategy — sharpens
-    //    silhouettes at disocclusion vs picking velocity at the centre).
-    let velocity = textureLoad(tVelocity, st + nearest_off, 0).rg;
-
-    // 3. Reproject to previous frame
-    let st_centre = vec2<f32>(st) + 0.5;
-    let prev_st_render = st_centre - velocity;
-    let prev_uv_render = prev_st_render / vec2<f32>(render_res);
-
-    // History lives at output resolution but the UV is the same in [0, 1].
-    let history_rgb = nss_warp_history_sample(prev_uv_render);
-
-    // 4. Disocclusion mask. The shared depth-clip pass returns FSR2
-    //    confidence (1 = trust history, 0 = disocclusion); ARM's network
-    //    input expects the inverse (high = disocclusion). Multiply by
-    //    history_validity so a hard reset zeros the mask too.
-    let confidence = textureLoad(tDisocclusionConfidence, st, 0).r;
-    let disocclusion_mask = (1.0 - saturate(confidence)) * saturate(settings.history_validity);
-
-    // 5. Warped feedback. Multiplied by history_validity so the very first
-    //    frame (or any reset) feeds neutral (0.5 raw -> 0 post-quant)
-    //    feedback to the network instead of garbage from an uninitialised
-    //    texture.
-    //
-    //    feedback_scale (debug knob, default 1.0) blends between actual FB
-    //    and the neutral value 0.5. At 0 the network sees raw 0.5 across
-    //    all FB channels, which post-quantize is ≈0 — the trained
-    //    "no signal" point, NOT a strong negative signal.
-    let feedback_actual = nss_warp_feedback_sample(prev_uv_render);
-    let feedback_neutral = vec4<f32>(0.5);
-    let feedback = mix(
-        feedback_neutral,
-        feedback_actual,
-        saturate(settings.history_validity) * saturate(settings.feedback_scale),
-    );
-
-    // 6. Current colour (load, no filtering — already at render-res)
-    let current_rgb = max(vec3<f32>(0.0), textureLoad(tColour, st, 0).rgb);
-
-    // 7. Luma derivative — uses raw colours; the chunk handles its own scaling.
-    let luma_deriv = nss_luma_derivative(current_rgb, history_rgb);
-
-    // Tonemap with EXPOSURE applied first — matches ARM's
-    // Tonemap(EXPOSURE * raw) training distribution. Raw [0, 1] tonemap
-    // (without exposure) lands values 2-5x below the network's trained
-    // operating point.
-    let history_t = nss_tonemap_exposure(history_rgb);
-    let current_t = nss_tonemap_exposure(current_rgb);
-
-    // Apply ARM's Quantize transformation in fp — converts our [0, 1] inputs
-    // into the [-1, 1] signed-int8 / 127 distribution the trained network
-    // expects (DC at 0, not +0.5). See nss_arm_quantize header for derivation.
-    // settings.quantize_inputs (default 1.0) blends between this transform
-    // and the raw [0, 1] tonemap (0.0). Useful as an A/B test knob.
-    let q = saturate(settings.quantize_inputs);
-    let history_q = mix(history_t, nss_arm_quantize_v3(history_t), q);
-    let current_q = mix(current_t, nss_arm_quantize_v3(current_t), q);
-    let disocclusion_q = mix(disocclusion_mask, nss_arm_quantize(disocclusion_mask), q);
-    let feedback_q = mix(feedback, nss_arm_quantize_v4(feedback), q);
-    let luma_deriv_q = mix(luma_deriv, nss_arm_quantize(luma_deriv), q);
-
-    // ── Pack into 12-channel tensor ──
-    // Layout (4ch × depth=3):
-    //   z=0 : history.rgb, current.r
-    //   z=1 : current.gb, disocclusion_mask, feedback.r
-    //   z=2 : feedback.gba, luma_derivative
-    textureStore(tTensor, vec3<i32>(st, 0), vec4<f32>(history_q, current_q.r));
-    textureStore(tTensor, vec3<i32>(st, 1), vec4<f32>(current_q.g, current_q.b, disocclusion_q, feedback_q.r));
-    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]
-    let nearest_packed = (vec2<f32>(nearest_off) + 1.0) * 0.5;
-    textureStore(tNearestOffset, st, vec4<f32>(nearest_packed, 0.0, 0.0));
-}
-    `, [
-        chunk_nss_find_nearest_depth,
-        chunk_nss_luma_derivative,
-        NSS_SETTINGS_STRUCT.declaration_chunk,
-    ]
-);
-
-export const shader_nss_preprocess = ComputeShader.from({
-    label: "NSS / preprocess",
-    body,
-    resources,
-    group_size: [NSS_WORKGROUP_SIZE, NSS_WORKGROUP_SIZE, 1],
-});
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { chunk_nss_find_nearest_depth } from "./chunk_nss_find_nearest_depth.js";
+import { chunk_nss_luma_derivative } from "./chunk_nss_luma_derivative.js";
+import { NSS_WORKGROUP_SIZE } from "./NSS_CONSTANTS.js";
+import { NSS_SETTINGS_STRUCT } from "./NSS_SETTINGS_STRUCT.js";
+
+/**
+ * NSS preprocess pass. Runs at render-resolution (one thread per render-res
+ * pixel) and produces:
+ *  1. The 12-channel network input tensor, packed into a single rgba16f
+ *     3D storage texture with depth=3 (channels 0..3, 4..7, 8..11).
+ *  2. The encoded "nearest depth offset" used by postprocess to dilate
+ *     velocity at output-res (`tNearestOffset` — components in [0, 1]
+ *     decode to {-1, 0, 1}² via `(x*2 - 1)`).
+ *
+ * Per-pixel logic (matches the algorithm in ARM's `Preprocess()`):
+ *   1. Dilate depth over a 3×3 neighbourhood, remember the offset of the
+ *      nearest sample.
+ *   2. Sample velocity at the dilated coord.
+ *   3. Project to the previous frame, sample warped history (bilinear).
+ *   4. Read the FSR2 depth-clip confidence from the upstream pass and
+ *      invert it into the network's "high = disocclusion" convention.
+ *   5. Sample the warped feedback tensor (bilinear).
+ *   6. Compute the luma derivative between current and warped history.
+ *   7. Pack everything into the output tensor — colours
+ *      tonemapped via `Tonemap(EXPOSURE * raw)` to match ARM's training
+ *      distribution.
+ *
+ * @see ARM NSS reference: `Preprocess` in
+ *      `Source/NG-SDK/sdk/include/FidelityFX/gpu/nss/ffx_nss_preprocess.h`
+ */
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    // ── inputs at render-res ──
+    .addTexture("tColour", "float")                          // jittered scene colour, render-res
+    // depth32float can't be bound as 'float' (filterable) — WebGPU only
+    // accepts depth textures via 'unfilterable-float' in this context.
+    // We only ever read this via textureLoad inside the depth dilation.
+    .addTexture("tDepthCurrent", "unfilterable-float")
+    .addTexture("tVelocity", "float")                        // pixel-space motion vectors, render-res
+    // FSR2 depth-clip confidence (1 = trust history, 0 = disocclusion)
+    // produced by the engine's shared shader_depth_occlusion_clip pass.
+    // We invert it into ARM's "high = disocclusion" network input.
+    .addTexture("tDisocclusionConfidence", "float")
+    // ── inputs at output-res / feedback at render-res ──
+    .addTexture("tHistory", "float")       // previous frame upscaled colour, output-res
+    .addTexture("tFeedbackIn", "float")    // 4-ch feedback tensor from previous frame, render-res
+    // ── settings ──
+    .addUniform("settings", NSS_SETTINGS_STRUCT)
+    // ── outputs ──
+    // Single rgba16f 3D storage texture holds the 12-channel input tensor
+    // packed across depth=3 layers (4 channels each). rgba16f gives the
+    // network ~10 bits of mantissa per channel, which is plenty for
+    // normalized [0, 1] inputs after the network's first BN/scale.
+    .addStorageTexture("tTensor", "rgba16float", "3d", "write-only")
+    // Nearest-depth offset packed as (dx+1, dy+1) / 2 -> [0, 1]. Postprocess
+    // uses this to fetch the velocity at the dilated coordinate when warping
+    // the history at output-resolution.
+    .addStorageTexture("tNearestOffset", "rg8unorm", "2d", "write-only")
+;
+
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const NSS_EXPOSURE: f32 = 7.38905609893; // e^2 — matches ARM's NSSCommon.ush
+
+// Karis tonemap (max-of-channels), applied to EXPOSURE-scaled colour.
+// ARM's training distribution: Tonemap(EXPOSURE * raw) -> network input.
+fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32> {
+    let scaled = rgb * NSS_EXPOSURE;
+    let m = max(max(scaled.r, scaled.g), scaled.b);
+    return scaled / (1.0 + m);
+}
+
+// ARM's network was trained against inputs that go through their Quantize
+// formula: int8 = round(fp * 255 - 128). The conv then sees (uint8 - 128)
+// = signed int8 in [-128, 127] - i.e. fp 0 -> -128, fp 0.5 -> 0, fp 1 -> 127.
+// Our pipeline naively feeds fp [0, 1] which has DC offset +0.5 vs ARM's
+// expected DC of 0. The trained head biases were calibrated against that
+// near-zero DC, so feeding +0.5 puts every conv accumulator off by
+// (sum_of_weights * 0.5 * 255) - way outside the trained operating range.
+//
+// We use the SMOOTH (no-round) version of ARM's transform: a linear
+// remap [0, 1] -> approx [-1.008, 1.008] clamped to [-1, 1]. Matches
+// ARM's DC shift but without the round() discontinuities that caused
+// feature-dependent flickering when small jitter-driven input changes
+// pushed pixels across quantization boundaries. Network sensitivity to
+// near-boundary inputs would otherwise flip int8 outputs by 1/127 per
+// frame and propagate through every layer.
+//
+// Per-multiply lands at ~(ARM signed * int8_w) / 127^2, so our acc is
+// approx (ARM int32_acc / 127^2). Our rescale_factor (= 127 * mult /
+// 2^shift) then produces value_fp ~ int8_in / 127 going into the LUT -
+// the shape ARM's network was trained to produce.
+fn nss_arm_quantize(fp: f32) -> f32 {
+    return clamp(fp * (255.0 / 127.0) - (128.0 / 127.0), -1.0, 1.0);
+}
+
+fn nss_arm_quantize_v3(rgb: vec3<f32>) -> vec3<f32> {
+    return vec3<f32>(nss_arm_quantize(rgb.r), nss_arm_quantize(rgb.g), nss_arm_quantize(rgb.b));
+}
+
+fn nss_arm_quantize_v4(v: vec4<f32>) -> vec4<f32> {
+    return vec4<f32>(nss_arm_quantize(v.x), nss_arm_quantize(v.y), nss_arm_quantize(v.z), nss_arm_quantize(v.w));
+}
+
+fn nss_warp_history_sample(prev_uv: vec2<f32>) -> vec3<f32> {
+    let on_screen = all(prev_uv >= vec2<f32>(0.0)) && all(prev_uv <= vec2<f32>(1.0));
+    if (!on_screen) {
+        return vec3<f32>(0.0);
+    }
+    // ARM uses bilinear (LoadHistory in ffx_nss_callbacks_glsl.h:471);
+    // Catmull-Rom is opt-in via HISTORY_CATMULL define.
+    return max(vec3<f32>(0.0), textureSampleLevel(tHistory, sLinear, prev_uv, 0.0).rgb);
+}
+
+fn nss_warp_feedback_sample(prev_uv_render: vec2<f32>) -> vec4<f32> {
+    let on_screen = all(prev_uv_render >= vec2<f32>(0.0)) && all(prev_uv_render <= vec2<f32>(1.0));
+    if (!on_screen) {
+        return vec4<f32>(0.0);
+    }
+    return textureSampleLevel(tFeedbackIn, sLinear, prev_uv_render, 0.0);
+}
+
+@compute @workgroup_size(${NSS_WORKGROUP_SIZE}, ${NSS_WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let render_res_u = settings.render_resolution;
+    let render_res = vec2<i32>(render_res_u);
+
+    if (any(gid.xy >= render_res_u)) {
+        return;
+    }
+
+    let st = vec2<i32>(gid.xy);
+
+    // 1. Depth dilation
+    var nearest_off = vec2<i32>(0, 0);
+    let _dilated_depth = nss_find_nearest_depth(tDepthCurrent, st, render_res, &nearest_off);
+
+    // 2. Velocity at the depth-nearest tap (FSR2 strategy — sharpens
+    //    silhouettes at disocclusion vs picking velocity at the centre).
+    let velocity = textureLoad(tVelocity, st + nearest_off, 0).rg;
+
+    // 3. Reproject to previous frame
+    let st_centre = vec2<f32>(st) + 0.5;
+    let prev_st_render = st_centre - velocity;
+    let prev_uv_render = prev_st_render / vec2<f32>(render_res);
+
+    // History lives at output resolution but the UV is the same in [0, 1].
+    let history_rgb = nss_warp_history_sample(prev_uv_render);
+
+    // 4. Disocclusion mask. The shared depth-clip pass returns FSR2
+    //    confidence (1 = trust history, 0 = disocclusion); ARM's network
+    //    input expects the inverse (high = disocclusion). Multiply by
+    //    history_validity so a hard reset zeros the mask too.
+    let confidence = textureLoad(tDisocclusionConfidence, st, 0).r;
+    let disocclusion_mask = (1.0 - saturate(confidence)) * saturate(settings.history_validity);
+
+    // 5. Warped feedback. Multiplied by history_validity so the very first
+    //    frame (or any reset) feeds neutral (0.5 raw -> 0 post-quant)
+    //    feedback to the network instead of garbage from an uninitialised
+    //    texture.
+    //
+    //    feedback_scale (debug knob, default 1.0) blends between actual FB
+    //    and the neutral value 0.5. At 0 the network sees raw 0.5 across
+    //    all FB channels, which post-quantize is ≈0 — the trained
+    //    "no signal" point, NOT a strong negative signal.
+    let feedback_actual = nss_warp_feedback_sample(prev_uv_render);
+    let feedback_neutral = vec4<f32>(0.5);
+    let feedback = mix(
+        feedback_neutral,
+        feedback_actual,
+        saturate(settings.history_validity) * saturate(settings.feedback_scale),
+    );
+
+    // 6. Current colour (load, no filtering — already at render-res)
+    let current_rgb = max(vec3<f32>(0.0), textureLoad(tColour, st, 0).rgb);
+
+    // 7. Luma derivative — uses raw colours; the chunk handles its own scaling.
+    let luma_deriv = nss_luma_derivative(current_rgb, history_rgb);
+
+    // Tonemap with EXPOSURE applied first — matches ARM's
+    // Tonemap(EXPOSURE * raw) training distribution. Raw [0, 1] tonemap
+    // (without exposure) lands values 2-5x below the network's trained
+    // operating point.
+    let history_t = nss_tonemap_exposure(history_rgb);
+    let current_t = nss_tonemap_exposure(current_rgb);
+
+    // Apply ARM's Quantize transformation in fp — converts our [0, 1] inputs
+    // into the [-1, 1] signed-int8 / 127 distribution the trained network
+    // expects (DC at 0, not +0.5). See nss_arm_quantize header for derivation.
+    // settings.quantize_inputs (default 1.0) blends between this transform
+    // and the raw [0, 1] tonemap (0.0). Useful as an A/B test knob.
+    let q = saturate(settings.quantize_inputs);
+    let history_q = mix(history_t, nss_arm_quantize_v3(history_t), q);
+    let current_q = mix(current_t, nss_arm_quantize_v3(current_t), q);
+    let disocclusion_q = mix(disocclusion_mask, nss_arm_quantize(disocclusion_mask), q);
+    let feedback_q = mix(feedback, nss_arm_quantize_v4(feedback), q);
+    let luma_deriv_q = mix(luma_deriv, nss_arm_quantize(luma_deriv), q);
+
+    // ── Pack into 12-channel tensor ──
+    // Layout (4ch × depth=3):
+    //   z=0 : history.rgb, current.r
+    //   z=1 : current.gb, disocclusion_mask, feedback.r
+    //   z=2 : feedback.gba, luma_derivative
+    textureStore(tTensor, vec3<i32>(st, 0), vec4<f32>(history_q, current_q.r));
+    textureStore(tTensor, vec3<i32>(st, 1), vec4<f32>(current_q.g, current_q.b, disocclusion_q, feedback_q.r));
+    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]
+    let nearest_packed = (vec2<f32>(nearest_off) + 1.0) * 0.5;
+    textureStore(tNearestOffset, st, vec4<f32>(nearest_packed, 0.0, 0.0));
+}
+    `, [
+        chunk_nss_find_nearest_depth,
+        chunk_nss_luma_derivative,
+        NSS_SETTINGS_STRUCT.declaration_chunk,
+    ]
+);
+
+export const shader_nss_preprocess = ComputeShader.from({
+    label: "NSS / preprocess",
+    body,
+    resources,
+});

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":"AAuDA,2CAWG;4BAjEyB,6BAA6B"}
+{"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"}

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

@@ -1,68 +1,70 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform("output_resolution", "vec2<u32>")
-    .addTexture("tInput");
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@fragment
-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;
-    
-    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++){
-        
-            let depth = textureLoad(tInput, vec2u(x,y), 0).r;
-            
-            max_value = max(depth, max_value);
-        }
-    }
-    
-    return max_value;
-}
-    `
-)
-
-export const depth_max_shader = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "Depth Reduce / max",
-        body,
-        resources,
-    }),
-    targets: [
-        {
-            format: "r32float"
-        }
-    ]
-});
-
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("output_resolution", "vec2<u32>");
+
+resources.createGroup()
+    .addTexture("tInput");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+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;
+    
+    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++){
+        
+            let depth = textureLoad(tInput, vec2u(x,y), 0).r;
+            
+            max_value = max(depth, max_value);
+        }
+    }
+    
+    return max_value;
+}
+    `
+)
+
+export const depth_max_shader = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Depth Reduce / max",
+        body,
+        resources,
+    }),
+    targets: [
+        {
+            format: "r32float"
+        }
+    ]
+});
+

package/src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.d.ts

@@ -1,3 +1,17 @@
-export const shader_ffx_denoiser_reflections_reproject: ComputeShader;
-import { ComputeShader } from "../../../shader/ComputeShader.js";
+/**
+ * An unfinished translation of the FidelityFX reflection denoiser's reprojection pass.
+ *
+ * Not yet a shader, and not yet valid WGSL: the body still carries HLSL spellings the port has not
+ * reached (`FfxFloat16x4`, `FfxInt32x2`, `FFX_GROUP_MEMORY_BARRIER`), and `main` is an empty stub
+ * with no `@compute` and no `@workgroup_size`. It was a `ComputeShader` here until the workgroup
+ * size started being read out of the WGSL, which is a question this source cannot answer; it stays
+ * a chunk until someone finishes the port and writes the entry point.
+ *
+ * The bindings it will want are one texture, `tRadiance`.
+ *
+ * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/sdk/include/FidelityFX/gpu/denoiser/ffx_denoiser_reflections_reproject.h
+ * @type {CodeChunk}
+ */
+export const chunk_ffx_denoiser_reflections_reproject: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=shader_ffx_denoiser_reflections_reproject.d.ts.map

package/src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_ffx_denoiser_reflections_reproject.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.js"],"names":[],"mappings":"AAqcA,sEAGG;8BApc2B,kCAAkC"}
+{"version":3,"file":"shader_ffx_denoiser_reflections_reproject.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,uDAFU,SAAS,CAubjB;0BArcwB,uCAAuC"}