@woosh/meep-engine 3.17.2 → 3.18.0

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

@@ -1,3 +1,6 @@
+import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
+import { ssr_resolve_shader_Brick4 } from "./resolve/ssr_resolve_shader_Brick4.js";
+import { SSRReprojectionMode } from "./SSRReprojectionMode.js";
 import { assert } from "../../../../core/assert.js";
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
@@ -9,7 +12,7 @@ import { ssr_combine_shader } from "./ssr_combine_shader.js";
 import { ssr_graph_prefilter_color } from "./ssr_graph_prefilter_color.js";
 import { SSR_PREFILTER_MIP_COUNT } from "./SSR_PREFILTER_MIP_COUNT.js";
 import { ssr_reproject_shader } from "./ssr_reproject_shader.js";
-import { ssr_spatial_denoise_shader } from "./ssr_spatial_denoise_shader.js";
+import { ssr_spatial_denoise_shader, ssr_spatial_denoise_metadata_shader } from "./ssr_spatial_denoise_shader.js";
 import { ssr_trace_shader } from "./ssr_trace_shader.js";
 
 export class SSR {
@@ -19,29 +22,74 @@ export class SSR {
      * @type {GPUTextureContext[]}
      */
     #history = [];
+    #metadata = [];
+    #geometry = [];
+    #read_index = 0;
+    #last_frame = -1;
+    #last_view;
+    #last_indirect_lighting_mode;
+    #last_jitter = [0, 0];
+    #valid = false;
+    #generation = 0;
+    #reset_history = true;
 
     frame_index = 0;
+    #reprojection_mode = SSRReprojectionMode.Parallax;
+    #spatial_denoising_enabled = true;
+
+    /** Toggle the three spatial passes independently of temporal reprojection. @returns {boolean} */
+    get spatial_denoising_enabled() { return this.#spatial_denoising_enabled; }
+    set spatial_denoising_enabled(value) {
+        assert.isBoolean(value, 'spatial_denoising_enabled');
+        if (value !== this.#spatial_denoising_enabled) {
+            this.#spatial_denoising_enabled = value;
+            // Pre-temporal filtering changes both radiance and its distance/support metadata.
+            this.reset_history = true;
+        }
+    }
+
+    /** @returns {SSRReprojectionMode} */
+    get reprojection_mode() { return this.#reprojection_mode; }
+    set reprojection_mode(value) {
+        assert.equal(Object.values(SSRReprojectionMode).includes(value), true, 'SSR reprojection mode');
+        if (value !== this.#reprojection_mode) {
+            this.#reprojection_mode = value;
+            this.reset_history = true;
+        }
+    }
 
     /**
      * When set, will disregard history buffer
      * Useful for camera cuts and large scene changes such as scene load
      * @type {boolean}
      */
-    reset_history = false;
+    get reset_history() { return this.#reset_history; }
+    set reset_history(value) {
+        this.#reset_history = value;
+        if (value) {
+            this.#valid = false;
+            this.#generation++;
+        }
+    }
 
     /**
      *
-     * @param {GraphicsContext} graphics
+     * @param {import("../../GraphicsContext.js").GraphicsContext} graphics
      */
     constructor(graphics) {
 
-        for (let i = 0; i < 2; i++) {
-            const texture = new GPUTextureContext(graphics.device);
-
-            texture.descriptor.format = "rgba16float";
-            texture.descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT;
-
-            this.#history[i] = texture;
+        for (const [history, format, label] of [
+            [this.#history, "rgba16float", "radiance"],
+            [this.#metadata, "rg32float", "metadata"],
+            [this.#geometry, "rgba16float", "geometry"],
+        ]) {
+            for (let i = 0; i < 2; i++) {
+                const texture = new GPUTextureContext(graphics.device);
+                texture.descriptor.label = `SSR history / ${label} ${i}`;
+                texture.descriptor.format = format;
+                texture.descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT;
+                history[i] = texture;
+            }
         }
     }
 
@@ -52,31 +100,45 @@ export class SSR {
      */
     resize(x, y) {
 
-        this.#history.forEach(t => t.resize(x, y));
+        if (this.#history[0].width !== x || this.#history[0].height !== y) {
+            this.reset_history = true;
+            for (const history of [this.#history, this.#metadata, this.#geometry]) {
+                history.forEach(t => t.resize(x, y));
+            }
+        }
     }
 
     /**
-     *
-     * @param {FrameGraph} graph
-     * @param {number} input_depth
-     * @param {number} input_hzb
-     * @param {number} input_scene_color
-     * @param {number} input_albedo
-     * @param {number} input_pbr
-     * @param {number} input_normal
-     * @param {number} input_velocity
-     * @param {number} input_occlusion
-     * @param {number[]} resolution
-     * @param {number} camera_current
-     * @param {number} camera_previous
-     * @param {GPULightProbeVolume} [lpv]
-     * @param {GPUViewContext} view_ctx
-     * @param {number} [mip] higher mip = lower resolution trace
-     * @returns {{final:number, trace:number, reflections:number, denoised: number}}
+     * Records SSR for one view; history becomes available after successful submission.
+     * @param {object} options
+     * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+     * @param {number} options.input_depth
+     * @param {number} [options.input_depth_previous] Same view and frame as camera_previous
+     * @param {number} options.input_hzb
+     * @param {number} options.input_scene_color
+     * @param {number} options.input_albedo
+     * @param {number} options.input_pbr
+     * @param {number} options.input_normal
+     * @param {number} options.input_velocity
+     * @param {number} options.input_occlusion
+     * @param {number} [options.input_environment]
+     * @param {ArrayLike<number>} options.resolution
+     * @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/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
+     * @param {number} [options.mip] Higher mip = lower resolution trace
+     * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number}}
      */
     graph_pass({
                    graph,
                    input_depth,
+                   input_depth_previous = -1,
+                   view_ctx,
+                   jitter = [0, 0],
                    input_hzb,
                    input_scene_color,
                    input_pbr,
@@ -88,22 +150,80 @@ export class SSR {
                    camera_current,
                    camera_previous,
                    input_environment = -1,
+                   indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
                    lpv,
+                   brick4,
                    mip = 0,
                }) {
 
         assert.defined(camera_current, 'camera');
 
-        this.resize(...resolution);
+        let resolve_shader;
+        let gi_inputs;
+        switch (indirect_lighting_mode) {
+            case ShadeIndirectLightingMode.IBL:
+                resolve_shader = ssr_resolve_shader_IBL;
+                gi_inputs = { tEnvironment: input_environment };
+                break;
+            case ShadeIndirectLightingMode.Brick4:
+                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 };
+                break;
+            case ShadeIndirectLightingMode.LPV:
+                assert.defined(lpv, 'SSR LPV');
+                resolve_shader = ssr_resolve_shader_LPV;
+                gi_inputs = {
+                    tEnvironment: input_environment,
+                    lpv_atlas_radiance: lpv.atlas.texture_radiance,
+                    lpv_atlas_depth: lpv.atlas.texture_depth,
+                    lpv_lookup: lpv.buffer_mesh_bvh,
+                    lpv_metadata: lpv.buffer_metadata,
+                    lpv_mesh: lpv.buffer_mesh,
+                    lpv_probes: lpv.buffer_probes,
+                };
+                break;
+            default:
+                throw new Error(`Unsupported SSR indirect lighting mode: ${indirect_lighting_mode}`);
+        }
+
+        this.resize(resolution[0], resolution[1]);
 
         // import history textures into the graph
         const frame_index = this.frame_index;
 
-        const h0 = this.#history[frame_index % 2];
-        const h1 = this.#history[(frame_index + 1) % 2];
-
-        const history = graph.import_resource("ssr_history", TextureResourceDescriptor.fromTexture(h0.gpu_texture), h0);
-        const output = graph.import_resource("ssr_output", TextureResourceDescriptor.fromTexture(h1.gpu_texture), h1);
+        const valid = this.#valid && !this.#reset_history && input_depth_previous >= 0
+            && this.#last_frame === frame_index - 1 && this.#last_view === view_ctx
+            && this.#last_indirect_lighting_mode === indirect_lighting_mode;
+        const read_index = this.#read_index;
+        const write_index = 1 - read_index;
+        const generation = ++this.#generation;
+        const current_jitter = Array.from(jitter);
+        const jitter_delta = current_jitter.map((v, i) => this.#last_jitter[i] - v);
+        // Recording a graph is not producing a frame. Failed/abandoned graphs cannot publish history.
+        this.#valid = false;
+        const import_texture = (textures, index, name) => {
+            const t = textures[index];
+            return graph.import_resource(name, TextureResourceDescriptor.fromTexture(t.gpu_texture), t);
+        };
+        const history = import_texture(this.#history, read_index, "ssr_history");
+        const history_metadata = import_texture(this.#metadata, read_index, "ssr_history_metadata");
+        const history_geometry = import_texture(this.#geometry, read_index, "ssr_history_geometry");
+        const output = import_texture(this.#history, write_index, "ssr_output");
+        const output_metadata = import_texture(this.#metadata, write_index, "ssr_output_metadata");
+        const output_geometry = import_texture(this.#geometry, write_index, "ssr_output_geometry");
+        graph.onExecuted.addOne(context => {
+            context.encoder.onFinished.addOne(() => {
+                if (this.#generation !== generation) { return; }
+                this.#read_index = write_index;
+                this.#last_frame = frame_index;
+                this.#last_view = view_ctx;
+                this.#last_indirect_lighting_mode = indirect_lighting_mode;
+                this.#last_jitter = current_jitter;
+                this.#reset_history = false;
+                this.#valid = true;
+            });
+        });
 
         // TODO trace at 1/2 resolution, resolve at full res and "steal" neighbour traces where possible
 
@@ -141,89 +261,68 @@ export class SSR {
             mip_count: SSR_PREFILTER_MIP_COUNT
         });
 
-        let reflections;
-
-        if (lpv !== undefined) {
-            [reflections] = graph_image_pass({
-                graph,
-                shader: ssr_resolve_shader_LPV,
-                output_resolution: resolution,
-                input_depth,
-                inputs: {
-                    settings: {
-                        frame_index
-                    },
-                    tEnvironment: input_environment,
-                    tTrace: trace,
-                    tColor: scene_color_filtered,
-                    tDepth: input_depth,
-                    tPBR: input_pbr,
-                    tAlbedoAO: input_albedo,
-                    tNormal: input_normal,
-                    camera: camera_current,
-                    lpv_atlas_radiance: lpv.atlas.texture_radiance,
-                    lpv_atlas_depth: lpv.atlas.texture_depth,
-                    //
-                    lpv_lookup: lpv.buffer_mesh_bvh,
-                    lpv_metadata: lpv.buffer_metadata,
-                    lpv_mesh: lpv.buffer_mesh,
-                    lpv_probes: lpv.buffer_probes,
-                }
-            });
-        } else {
-            [reflections] = graph_image_pass({
-                graph,
-                shader: ssr_resolve_shader_IBL,
-                output_resolution: resolution,
-                input_depth,
-                inputs: {
-                    settings: {
-                        frame_index
-                    },
-                    tEnvironment: input_environment,
-                    tTrace: trace,
-                    tColor: scene_color_filtered,
-                    tDepth: input_depth,
-                    tPBR: input_pbr,
-                    tAlbedoAO: input_albedo,
-                    tNormal: input_normal,
-                    camera: camera_current,
-                }
-            });
-        }
+        const [reflections, reflection_metadata] = graph_image_pass({
+            graph,
+            shader: resolve_shader,
+            output_resolution: resolution,
+            input_depth,
+            inputs: {
+                ...gi_inputs,
+                settings: { frame_index },
+                tTrace: trace,
+                tColor: scene_color_filtered,
+                tDepth: input_depth,
+                tPBR: input_pbr,
+                tAlbedoAO: input_albedo,
+                tNormal: input_normal,
+                camera: camera_current,
+            },
+        });
 
-        // TODO handle history reset
+        // History validity is captured above and consumed by temporal reprojection.
 
         // denoise
 
         let denoised = reflections;
+        let denoised_metadata = reflection_metadata;
 
         // before doing TAA we apply spatial denoise, this improves stability at the cost of a little extra blurriness
         // based on SEED hybrid rendering paper as well as AMDs reflection denoiser
 
-        [denoised] = graph_image_pass({
-            graph,
-            shader: ssr_spatial_denoise_shader,
-            output_resolution: resolution,
-            inputs: {
-                tInput: denoised,
-                tDepth: input_depth,
-                tNormal: input_normal,
-                settings: {
-                    // see AMD's notes on A-torus, this produces following filter sizes: 1, 2, 4
-                    step_size: 1,
+        if (this.#spatial_denoising_enabled) {
+            [denoised, denoised_metadata] = graph_image_pass({
+                graph,
+                shader: ssr_spatial_denoise_metadata_shader,
+                output_resolution: resolution,
+                inputs: {
+                    tInput: denoised,
+                    tMetadata: denoised_metadata,
+                    tDepth: input_depth,
+                    tNormal: input_normal,
+                    settings: {
+                        // see AMD's notes on A-torus, this produces following filter sizes: 1, 2, 4
+                        step_size: 1,
+                    }
                 }
-            }
-        });
+            });
+        }
         const denoised_1 = denoised;
 
-        [denoised] = graph_image_pass({
+        [denoised, denoised_metadata] = graph_image_pass({
             graph,
             shader: ssr_reproject_shader,
-            output: [output],
+            output: [output, output_metadata, output_geometry],
             inputs: {
                 tInput: denoised,
+                tMetadata: denoised_metadata,
                 tHistory: history,
+                tHistoryMetadata: history_metadata,
+                tHistoryGeometry: history_geometry,
+                tPreviousDepth: input_depth_previous >= 0 ? input_depth_previous : input_depth,
+                tDepth: input_depth,
+                tNormal: input_normal,
+                tPBR: input_pbr,
+                settings: { history_validity: valid ? 1 : 0, reprojection_mode: this.#reprojection_mode, jitter_delta },
                 tVelocity: input_velocity,
                 tOcclusion: input_occlusion,
                 camera_current,
@@ -231,36 +330,38 @@ export class SSR {
             }
         });
 
-        // 2 more spatial denoise steps
-        [denoised] = graph_image_pass({
-            graph,
-            shader: ssr_spatial_denoise_shader,
-            output_resolution: resolution,
-            inputs: {
-                tInput: denoised,
-                tDepth: input_depth,
-                tNormal: input_normal,
-                settings: {
-                    // see AMD's notes on A-torus, this produces following filter sizes: 1, 2, 4
-                    step_size: 2,
+        if (this.#spatial_denoising_enabled) {
+            // 2 more spatial denoise steps
+            [denoised] = graph_image_pass({
+                graph,
+                shader: ssr_spatial_denoise_shader,
+                output_resolution: resolution,
+                inputs: {
+                    tInput: denoised,
+                    tDepth: input_depth,
+                    tNormal: input_normal,
+                    settings: {
+                        // see AMD's notes on A-torus, this produces following filter sizes: 1, 2, 4
+                        step_size: 2,
+                    }
                 }
-            }
-        });
+            });
 
-        [denoised] = graph_image_pass({
-            graph,
-            shader: ssr_spatial_denoise_shader,
-            output_resolution: resolution,
-            inputs: {
-                tInput: denoised,
-                tDepth: input_depth,
-                tNormal: input_normal,
-                settings: {
-                    // see AMD's notes on A-torus, this produces following filter sizes: 1, 2, 4
-                    step_size: 4,
+            [denoised] = graph_image_pass({
+                graph,
+                shader: ssr_spatial_denoise_shader,
+                output_resolution: resolution,
+                inputs: {
+                    tInput: denoised,
+                    tDepth: input_depth,
+                    tNormal: input_normal,
+                    settings: {
+                        // see AMD's notes on A-torus, this produces following filter sizes: 1, 2, 4
+                        step_size: 4,
+                    }
                 }
-            }
-        });
+            });
+        }
 
         const [final] = graph_image_pass({
             graph,
@@ -277,7 +378,7 @@ export class SSR {
             }
         });
 
-        this.reset_history = false;
+
 
         // technically we only need 'final' others are for debugging
 
@@ -289,4 +390,4 @@ export class SSR {
             reflections,
         };
     }
-}
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Diagnostic comparisons share the same resolve, validation and spatial filtering.
+ */
+export type SSRReprojectionMode = number;
+/** Diagnostic comparisons share the same resolve, validation and spatial filtering. @enum {number} */
+export const SSRReprojectionMode: Readonly<{
+    Parallax: 0;
+    Surface: 1;
+    CurrentFrame: 2;
+}>;
+//# sourceMappingURL=SSRReprojectionMode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SSRReprojectionMode.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSRReprojectionMode.js"],"names":[],"mappings":";;;kCAA4F,MAAM;AAAlG,sGAAsG;AACtG;;;;GAIG"}

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

@@ -0,0 +1,6 @@
+/** Diagnostic comparisons share the same resolve, validation and spatial filtering. @enum {number} */
+export const SSRReprojectionMode = Object.freeze({
+    Parallax: 0,
+    Surface: 1,
+    CurrentFrame: 2,
+});

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

@@ -0,0 +1,4 @@
+/** Distance and support describe the radiance mixture, including spatially borrowed samples. */
+export const chunk_ssr_metadata: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ssr_metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_metadata.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/chunk_ssr_metadata.js"],"names":[],"mappings":"AAGA,gGAAgG;AAChG,2CA2BsB;0BA/BI,oCAAoC"}

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

@@ -0,0 +1,32 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
+
+/** Distance and support describe the radiance mixture, including spatially borrowed samples. */
+export const chunk_ssr_metadata = CodeChunk.from(/* language=WGSL */ `
+struct SSRResolveOutput {
+    @location(0) radiance: vec4f,
+    @location(1) metadata: vec2f,
+}
+
+// (supported first/second distance moments, supported weight, total radiance weight).
+// A miss still contributes total weight when mixed into an existing radiance signal.
+fn ssr_distance_moments(distance: f32, support: f32, weight: f32) -> vec4f {
+    if (!is_finite(weight) || weight <= 0.0) { return vec4f(0.0); }
+    if (!is_finite(distance) || distance <= 0.0 || !is_finite(support)) {
+        return vec4f(0.0, 0.0, 0.0, weight);
+    }
+    let w = weight * saturate(support);
+    return vec4f(w * distance, w * distance * distance, w, weight);
+}
+
+fn ssr_resolve_metadata(moments: vec4f, source_fraction: f32) -> vec2f {
+    if (moments.z <= 1e-6 || moments.w <= 1e-6) { return vec2f(0.0); }
+    let distance = moments.x / moments.z;
+    let variance = max(0.0, moments.y / moments.z - distance * distance);
+    // Reject broad mixtures instead of treating the average as a real reflected depth.
+    let coherence = saturate(1.0 - sqrt(variance) / max(0.1 * distance, 1e-5));
+    let support = coherence * saturate(moments.z / moments.w) * saturate(source_fraction);
+    if (!is_finite(distance) || !is_finite(support)) { return vec2f(0.0); }
+    return vec2f(distance, support);
+}
+`, [chunk_is_finite]);

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

@@ -0,0 +1,4 @@
+/** Bootstrap variance from spatial samples when resolve has too few rays to estimate noise. */
+export const chunk_ssr_spatial_variance: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ssr_spatial_variance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_spatial_variance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/chunk_ssr_spatial_variance.js"],"names":[],"mappings":"AAQA,+FAA+F;AAC/F,mDA+B4H;0BAxClG,oCAAoC"}

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

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
+import { chunk_is_on_screen_i32 } from "../../shader/chunk/texture/chunk_is_on_screen_i32.js";
+import { chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight } from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight.js";
+import { chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight } from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight.js";
+
+/** Bootstrap variance from spatial samples when resolve has too few rays to estimate noise. */
+export const chunk_ssr_spatial_variance = CodeChunk.from(/* language=WGSL */ `
+fn ssr_spatial_variance(
+    radiance: texture_2d<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>, p: vec2i,
+) -> f32 {
+    let center_luma = rgb_to_luminance(textureLoad(radiance,p,0).rgb);
+    let center_normal = decode_g_buffer_normal(textureLoad(normals,p,0).xy);
+    let center_depth = textureLoad(depth,p,0).r;
+    let size = vec2i(textureDimensions(radiance));
+    let kernel = array<f32,3>(0.25,0.125,0.0625);
+    var moments = vec2f(0.0);
+    var sum_weight = 0.0;
+    for (var y = -1; y <= 1; y++) {
+        for (var x = -1; x <= 1; x++) {
+            let q = p + vec2i(x,y);
+            if (!is_on_screen_i32(q,size)) { continue; }
+            let sample_normal = decode_g_buffer_normal(textureLoad(normals,q,0).xy);
+            let sample_depth = textureLoad(depth,q,0).r;
+            let weight = kernel[abs(x)+abs(y)]
+                * ffx_dnsr_reflections_get_edge_stopping_normal_weight(center_normal,sample_normal)
+                * ffx_dnsr_reflections_get_edge_stopping_depth_weight(center_depth,sample_depth);
+            // Differences about the centre avoid cancellation for a constant HDR signal.
+            let delta = rgb_to_luminance(textureLoad(radiance,q,0).rgb)-center_luma;
+            moments += vec2f(delta,delta*delta)*weight;
+            sum_weight += weight;
+        }
+    }
+    moments /= max(sum_weight,1e-8);
+    let sigma = get_std_dev(moments.x,moments.y);
+    return sigma*sigma;
+}
+`, [chunk_rgb_to_luminance, chunk_decode_g_buffer_normal, chunk_get_std_dev, chunk_is_on_screen_i32,
+    chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight, chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight]);

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

@@ -0,0 +1,3 @@
+export const chunk_ssr_reprojection: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ssr_reprojection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_reprojection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_reprojection.js"],"names":[],"mappings":"AAIA,+CAyBuC;0BA7Bb,uCAAuC"}

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_reprojection.js

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_ndc_to_uv } from "../../../shader/chunk/texture/chunk_ndc_to_uv.js";
+import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
+
+export const chunk_ssr_reprojection = CodeChunk.from(/* language=WGSL */ `
+fn ssr_virtual_position(camera_position: vec3f, surface: vec3f, distance: f32) -> vec3f {
+    let ray = surface - camera_position;
+    return surface + ray * (distance / max(length(ray), 1e-6));
+}
+
+// Matrices address the raster grids, including jitter. Invalid projections never sample history.
+fn ssr_history_uv(position: vec3f, previous_view_projection: mat4x4f) -> vec2f {
+    let clip = previous_view_projection * vec4f(position, 1.0);
+    if (!is_finite(clip.w) || clip.w <= 1e-6) { return vec2f(-1.0); }
+    let uv = ndc_to_uv(clip.xy / clip.w);
+    if (!is_finite(uv.x) || !is_finite(uv.y)) { return vec2f(-1.0); }
+    return uv;
+}
+
+fn ssr_surface_history_uv(pixel: vec2f, velocity: vec2f, jitter_delta: vec2f, size: vec2f) -> vec2f {
+    return (pixel - velocity + jitter_delta) / size;
+}
+
+// Apply confidence LAST. Variance and clamp heuristics cannot resurrect rejected history.
+fn ssr_history_weight(current_variance: f32, history_variance: f32, current_blend: f32, confidence: f32) -> f32 {
+    let c = current_blend / (1.0 + max(current_variance, 0.0));
+    let h = (1.0 - current_blend) / (1.0 + max(history_variance, 0.0));
+    return h / max(c + h, 1e-20) * saturate(confidence);
+}
+`, [chunk_ndc_to_uv, chunk_is_finite]);

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

@@ -0,0 +1,4 @@
+/** Resource names are supplied by ssr_reproject_shader. Validate exactly the taps we read. */
+export const chunk_ssr_sample_history: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ssr_sample_history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_sample_history.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.js"],"names":[],"mappings":"AAUA,8FAA8F;AAC9F,iDA0DkD;0BArExB,uCAAuC"}