@woosh/meep-engine 2.170.0 → 3.0.1

package/src/shade/renderer/restir/di/shader_restir_di_denoise.js

@@ -0,0 +1,137 @@
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_normal_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
+import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.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 { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+
+/**
+ * ReSTIR DI — spatial denoise pass (edge-aware à-trous).
+ *
+ * A tailored, ReSTIR-aware spatial filter for the resolved point/spot radiance.
+ * One iteration of the à-trous (hole-filled) wavelet: a 3x3 neighbourhood dilated
+ * by `step_size`, run a few times with step 1, 2, 4 (driven by the graph) to grow
+ * the effective footprint while keeping the per-pass cost at 8 taps. The
+ * edge-stopping is SVGF-style — geometry edges from linear depth + normal (always
+ * safe to stop on), plus a gentle relative-luma term to preserve shadow edges.
+ *
+ * Deliberately spatial-only: the engine's TAA and ReSTIR's own reservoir temporal
+ * reuse already supply the temporal axis, so we do NOT add a second temporal
+ * reproject (that is the LigmaDenoiser path the user flagged as imperfect).
+ *
+ * Operates on the modulated radiance (BRDF already folded in). Albedo-edge
+ * demodulation is a possible later refinement; depth+normal stopping already holds
+ * the geometric edges that matter most for direct lighting.
+ *
+ * No storage buffers (textures + uniforms only), so it is unaffected by the
+ * maxStorageBuffersPerShaderStage budget the resolve/resample passes fight for.
+ *
+ * @type {ComputeShader}
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("tInput")
+    .addTexture("gBufferDepth")
+    .addTexture("gBufferNormal", "uint")
+    .addStorageTexture("output", "rgba16float", "2d", "write-only")
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("step_size", u32);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+// Edge-stopping tolerances. Tighter = preserves more detail (less denoising).
+const PHI_NORMAL: f32 = 64.0;   // normal power; higher stops sooner on curvature
+const PHI_DEPTH: f32 = 0.02;    // relative linear-depth tolerance (fraction of depth)
+const PHI_LUMA: f32 = 0.6;      // relative luma tolerance (fraction of centre luma)
+
+@compute @workgroup_size(8, 8, 1)
+fn main(
+    @builtin(global_invocation_id) global_invocation_id: vec3<u32>,
+) {
+    let i_coord = vec2<i32>(global_invocation_id.xy);
+    let screen_size = vec2<i32>(textureDimensions(tInput));
+
+    if (!all(i_coord < screen_size)) {
+        return;
+    }
+
+    let center_device_depth = textureLoad(gBufferDepth, i_coord, 0).r;
+    let center_radiance = textureLoad(tInput, i_coord, 0).rgb;
+
+    // Background carries no ReSTIR radiance — pass it through so the filter neither
+    // bleeds lit neighbours into it nor pulls it into lit pixels.
+    if (is_background(center_device_depth)) {
+        textureStore(output, global_invocation_id.xy, vec4<f32>(center_radiance, 1.0));
+        return;
+    }
+
+    let center_depth = get_view_space_depth(center_device_depth, camera);
+    let center_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, i_coord, 0).xy);
+    let center_luma = rgb_to_luminance(center_radiance);
+
+    let step = i32(step_size);
+
+    const kernel_weights = array<f32, 2>(1.0, 2.0 / 3.0);
+    const offsets = array<vec2<i32>, 8>(
+        vec2<i32>(-1, -1), vec2<i32>(0, -1), vec2<i32>(1, -1),
+        vec2<i32>(-1,  0),                   vec2<i32>(1,  0),
+        vec2<i32>(-1,  1), vec2<i32>(0,  1), vec2<i32>(1,  1),
+    );
+
+    // centre weight 1, accumulate neighbours
+    var sum_w = 1.0;
+    var sum_rgb = center_radiance;
+
+    for (var i = 0; i < 8; i++) {
+        let offset = offsets[i];
+        let p = i_coord + offset * step;
+
+        if (!(all(p >= vec2<i32>(0, 0)) && all(p < screen_size))) {
+            continue;
+        }
+
+        let sample_device_depth = textureLoad(gBufferDepth, p, 0).r;
+        if (is_background(sample_device_depth)) {
+            continue;
+        }
+
+        let sample_radiance = textureLoad(tInput, p, 0).rgb;
+        let sample_depth = get_view_space_depth(sample_device_depth, camera);
+        let sample_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, p, 0).xy);
+        let sample_luma = rgb_to_luminance(sample_radiance);
+
+        let w_normal = normal_edge_stopping_weight(center_normal, sample_normal, PHI_NORMAL);
+        let d_depth = abs(center_depth - sample_depth) / (PHI_DEPTH * max(center_depth, 1e-3));
+        let d_luma = abs(center_luma - sample_luma) / (PHI_LUMA * center_luma + 1e-3);
+
+        let kernel = kernel_weights[abs(offset.x)] * kernel_weights[abs(offset.y)];
+        let w = exp(-(d_depth + d_luma)) * w_normal * kernel;
+
+        sum_w += w;
+        sum_rgb += w * sample_radiance;
+    }
+
+    textureStore(output, global_invocation_id.xy, vec4<f32>(sum_rgb / sum_w, 1.0));
+}
+    `, [
+        chunk_is_background,
+        chunk_get_view_space_depth,
+        chunk_decode_g_buffer_normal,
+        chunk_rgb_to_luminance,
+        chunk_normal_edge_stopping_weight,
+    ]
+);
+
+export const shader_restir_di_denoise = ComputeShader.from({
+    label: "ReSTIR DI Denoise",
+    resources,
+    body,
+    group_size: [8, 8, 1],
+});

package/src/shade/renderer/restir/di/shader_restir_di_resample.d.ts

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

package/src/shade/renderer/restir/di/shader_restir_di_resample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_restir_di_resample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/shader_restir_di_resample.js"],"names":[],"mappings":"AA4HA,sDAKG;8BAtH2B,+BAA+B"}

package/src/shade/renderer/restir/di/shader_restir_di_resample.js

@@ -0,0 +1,130 @@
+import { u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_rtxdi_empty_reservoir } from "../reservoir/chunk_rtxdi_empty_reservoir.js";
+import { chunk_rtxdi_pack_reservoir } from "../reservoir/chunk_rtxdi_pack_reservoir.js";
+import { RTXDI_PackedReservoir } from "../reservoir/RTXDI_PackedReservoir.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_stbn_sample_vec2 } from "../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../../light/cluster/shader_cluster_assign_lights.js";
+import { chunk_random } from "../../shader/chunk/random/chunk_random.js";
+import { chunk_random_initialize } from "../../shader/chunk/random/chunk_random_initialize.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_restir_generate_candidates } from "./chunk_restir_generate_candidates.js";
+import { chunk_restir_reconstruct_surface } from "./chunk_restir_reconstruct_surface.js";
+import { chunk_restir_reservoir_address } from "./chunk_restir_reservoir_address.js";
+import { chunk_restir_temporal_reuse } from "./chunk_restir_temporal_reuse.js";
+
+/**
+ * ReSTIR DI — resample pass (stage 1 of 2).
+ *
+ * Per pixel: reconstruct the surface, draw M_initial candidate local lights from
+ * the froxel cluster (RIS / WRS with the BRDF target function), temporally
+ * resample against the reprojected previous-frame reservoir, and write the
+ * finalized reservoir to `reservoir_current`.
+ *
+ * Deliberately holds NO ray-tracing bindings: visibility is deferred to the
+ * resolve pass, which keeps this pass at 5 storage buffers (lights + clusters +
+ * the two reservoirs) — within maxStorageBuffersPerShaderStage. The visibility
+ * ray + shading is the resolve pass's job.
+ *
+ * @type {ComputeShader}
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+// G-buffer + reprojection inputs + uniforms (no storage buffers in this group).
+resources.createGroup()
+    .addTexture("gBufferDepth")
+    .addTexture("gBufferPBR")
+    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferAlbedo")
+    .addTexture("gBufferEmissive", "uint")
+    .addTexture("VelocityBuffer")
+    .addTexture("tOcclusionClip")
+    .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addUniform("m_initial", u32);
+
+// Local lights + froxel clusters (the screen-space tile candidate set).
+const RESTIR_DI_LIGHT_GROUP = new ShaderResourceGroupDescriptor();
+RESTIR_DI_LIGHT_GROUP.label = "restir-di/lights";
+RESTIR_DI_LIGHT_GROUP
+    .addStorageBuffer("light_data", WebGPUArray.u32)
+    .addUniform("cluster_parameters", vec3f)
+    .addStorageBuffer("cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT)
+    .addStorageBuffer("cluster_data", WebGPUArray.u32);
+resources.addGroup(RESTIR_DI_LIGHT_GROUP);
+
+// Previous frame's spatiotemporal reservoir (read) + this pass's output (write).
+// The output is a transient scratch the spatial pass consumes; the persistent
+// ping-pong final reservoir is written by the spatial pass.
+const RESTIR_DI_RESERVOIR_GROUP = new ShaderResourceGroupDescriptor();
+RESTIR_DI_RESERVOIR_GROUP.label = "restir-di/reservoirs";
+RESTIR_DI_RESERVOIR_GROUP
+    .addStorageBuffer("reservoir_out", WebGPUArray.from(RTXDI_PackedReservoir), true)
+    .addStorageBuffer("reservoir_previous", WebGPUArray.from(RTXDI_PackedReservoir), false);
+resources.addGroup(RESTIR_DI_RESERVOIR_GROUP);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(8, 8, 1)
+fn main(
+    @builtin(global_invocation_id) global_invocation_id: vec3<u32>,
+) {
+    let i_coord = global_invocation_id.xy;
+    let texture_size = textureDimensions(gBufferDepth);
+
+    if (!all(i_coord < texture_size)) {
+        return;
+    }
+
+    // Per-pixel, per-frame PRNG for candidate sampling + area-light jitter.
+    random_initialize(vec3<u32>(i_coord, view.frame_index), vec3<u32>(0x9E3779B9u, 0x85EBCA6Bu, 0xC2B2AE35u));
+
+    var reservoir = rtxdi_empty_reservoir();
+
+    let surface = restir_reconstruct_surface(i_coord, texture_size);
+    if (surface.is_valid) {
+        // Blue-noise area-light sample coordinate (spatially-visible dimension).
+        let stbn_uv = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index));
+
+        let canonical = restir_generate_candidates(
+            surface.geometry,
+            surface.material,
+            vec2<f32>(i_coord) + vec2<f32>(0.5, 0.5),
+            surface.view_depth,
+            texture_size,
+            m_initial,
+            stbn_uv,
+        );
+
+        reservoir = restir_temporal_reuse(canonical, surface.geometry, surface.material, i_coord, texture_size);
+    }
+
+    reservoir_out[restir_reservoir_address(i_coord, texture_size.x)] = rtxdi_pack_reservoir(reservoir);
+}
+    `, [
+        chunk_restir_reconstruct_surface,
+        chunk_restir_generate_candidates,
+        chunk_restir_temporal_reuse,
+        chunk_stbn_sample_vec2,
+        chunk_rtxdi_empty_reservoir,
+        chunk_rtxdi_pack_reservoir,
+        chunk_restir_reservoir_address,
+        chunk_random,
+        chunk_random_initialize,
+    ]
+);
+
+export const shader_restir_di_resample = ComputeShader.from({
+    label: "ReSTIR DI Resample",
+    resources,
+    body,
+    group_size: [8, 8, 1],
+});

package/src/shade/renderer/restir/di/shader_restir_di_resolve.d.ts

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

package/src/shade/renderer/restir/di/shader_restir_di_resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_restir_di_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/shader_restir_di_resolve.js"],"names":[],"mappings":"AA8FA,qDAKG;8BA7F2B,+BAA+B"}

package/src/shade/renderer/restir/di/shader_restir_di_resolve.js

@@ -0,0 +1,100 @@
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_rtxdi_unpack_reservoir } from "../reservoir/chunk_rtxdi_unpack_reservoir.js";
+import { RTXDI_PackedReservoir } from "../reservoir/RTXDI_PackedReservoir.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { sr_create_group_RTX } from "../../geometry/sr_create_group_RTX.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_restir_reconstruct_surface } from "./chunk_restir_reconstruct_surface.js";
+import { chunk_restir_reservoir_address } from "./chunk_restir_reservoir_address.js";
+import { chunk_restir_resolve } from "./chunk_restir_resolve.js";
+
+/**
+ * ReSTIR DI — resolve pass (stage 2 of 2).
+ *
+ * Per pixel: reconstruct the surface, read the reservoir the resample pass wrote,
+ * and resolve it to outgoing radiance — full RGB BRDF * W * visibility, with one
+ * opaque shadow ray. Holds the 7-buffer ray-tracing group plus light_data + the
+ * reservoir (9 storage buffers), within maxStorageBuffersPerShaderStage. The
+ * candidate generation + temporal reuse (which need the cluster + the second
+ * reservoir) live in the resample pass.
+ *
+ * @type {ComputeShader}
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+// G-buffer + radiance output + uniforms.
+resources.createGroup()
+    .addTexture("gBufferDepth")
+    .addTexture("gBufferPBR")
+    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferAlbedo")
+    .addTexture("gBufferEmissive", "uint")
+    // Depth + HiZ pyramid for the hybrid screen-space hand-off trace.
+    .addTexture("tDepth")
+    .addTexture("tHZB")
+    .addStorageTexture("output", "rgba16float", "2d", "write-only")
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addUniform("use_screen_space_shadow", u32);
+
+// Local light tables (resolve re-evaluates the selected light; no clusters needed).
+const RESTIR_DI_RESOLVE_LIGHT_GROUP = new ShaderResourceGroupDescriptor();
+RESTIR_DI_RESOLVE_LIGHT_GROUP.label = "restir-di/resolve-lights";
+RESTIR_DI_RESOLVE_LIGHT_GROUP.addStorageBuffer("light_data", WebGPUArray.u32);
+resources.addGroup(RESTIR_DI_RESOLVE_LIGHT_GROUP);
+
+// Ray-tracing acceleration structure + geometry (opaque visibility ray).
+sr_create_group_RTX(resources);
+
+// The reservoir written by the resample pass (read-only here).
+const RESTIR_DI_RESOLVE_RESERVOIR_GROUP = new ShaderResourceGroupDescriptor();
+RESTIR_DI_RESOLVE_RESERVOIR_GROUP.label = "restir-di/resolve-reservoir";
+RESTIR_DI_RESOLVE_RESERVOIR_GROUP.addStorageBuffer("reservoir_current", WebGPUArray.from(RTXDI_PackedReservoir), false);
+resources.addGroup(RESTIR_DI_RESOLVE_RESERVOIR_GROUP);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(8, 8, 1)
+fn main(
+    @builtin(global_invocation_id) global_invocation_id: vec3<u32>,
+) {
+    let i_coord = global_invocation_id.xy;
+    let texture_size = textureDimensions(gBufferDepth);
+
+    if (!all(i_coord < texture_size)) {
+        return;
+    }
+
+    let surface = restir_reconstruct_surface(i_coord, texture_size);
+    if (!surface.is_valid) {
+        textureStore(output, i_coord, vec4<f32>(0.0, 0.0, 0.0, 0.0));
+        return;
+    }
+
+    let reservoir = rtxdi_unpack_reservoir(reservoir_current[restir_reservoir_address(i_coord, texture_size.x)]);
+
+    let radiance = restir_resolve(i_coord, reservoir, surface.geometry, surface.material, use_screen_space_shadow);
+
+    textureStore(output, i_coord, vec4<f32>(radiance, 1.0));
+}
+    `, [
+        chunk_restir_reconstruct_surface,
+        chunk_rtxdi_unpack_reservoir,
+        chunk_restir_resolve,
+        chunk_restir_reservoir_address,
+    ]
+);
+
+export const shader_restir_di_resolve = ComputeShader.from({
+    label: "ReSTIR DI Resolve",
+    resources,
+    body,
+    group_size: [8, 8, 1],
+});

package/src/shade/renderer/restir/di/shader_restir_di_spatial.d.ts

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

package/src/shade/renderer/restir/di/shader_restir_di_spatial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_restir_di_spatial.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/shader_restir_di_spatial.js"],"names":[],"mappings":"AA+GA,qDAKG;8BA3G2B,+BAA+B"}

package/src/shade/renderer/restir/di/shader_restir_di_spatial.js

@@ -0,0 +1,117 @@
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_rtxdi_pack_reservoir } from "../reservoir/chunk_rtxdi_pack_reservoir.js";
+import { chunk_rtxdi_unpack_reservoir } from "../reservoir/chunk_rtxdi_unpack_reservoir.js";
+import { RTXDI_PackedReservoir } from "../reservoir/RTXDI_PackedReservoir.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_stbn_sample_vec2 } from "../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import { chunk_random } from "../../shader/chunk/random/chunk_random.js";
+import { chunk_random_initialize } from "../../shader/chunk/random/chunk_random_initialize.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_restir_reconstruct_surface } from "./chunk_restir_reconstruct_surface.js";
+import { chunk_restir_reservoir_address } from "./chunk_restir_reservoir_address.js";
+import { chunk_restir_spatial_reuse } from "./chunk_restir_spatial_reuse.js";
+
+/**
+ * ReSTIR DI — spatial pass (between resample and resolve).
+ *
+ * Reads the resample pass's reservoir for the pixel and its neighbours
+ * (`reservoir_input`), combines them with geometric rejection, and writes the
+ * spatiotemporal result to `reservoir_output` — which the resolve pass shades and
+ * which becomes next frame's temporal history.
+ *
+ * Holds light_data + the two reservoir buffers = 3 storage buffers (no ray
+ * tracing, no clusters), well within maxStorageBuffersPerShaderStage.
+ *
+ * @type {ComputeShader}
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+// G-buffer (surface reconstruct + neighbour rejection) + uniforms.
+resources.createGroup()
+    .addTexture("gBufferDepth")
+    .addTexture("gBufferPBR")
+    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferAlbedo")
+    .addTexture("gBufferEmissive", "uint")
+    .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT);
+
+// Local light tables (recompute neighbour target functions; no clusters needed).
+const RESTIR_DI_SPATIAL_LIGHT_GROUP = new ShaderResourceGroupDescriptor();
+RESTIR_DI_SPATIAL_LIGHT_GROUP.label = "restir-di/spatial-lights";
+RESTIR_DI_SPATIAL_LIGHT_GROUP.addStorageBuffer("light_data", WebGPUArray.u32);
+resources.addGroup(RESTIR_DI_SPATIAL_LIGHT_GROUP);
+
+// Input = resample output (read, incl. neighbours), output = spatiotemporal final.
+const RESTIR_DI_SPATIAL_RESERVOIR_GROUP = new ShaderResourceGroupDescriptor();
+RESTIR_DI_SPATIAL_RESERVOIR_GROUP.label = "restir-di/spatial-reservoirs";
+RESTIR_DI_SPATIAL_RESERVOIR_GROUP
+    .addStorageBuffer("reservoir_input", WebGPUArray.from(RTXDI_PackedReservoir), false)
+    .addStorageBuffer("reservoir_output", WebGPUArray.from(RTXDI_PackedReservoir), true);
+resources.addGroup(RESTIR_DI_SPATIAL_RESERVOIR_GROUP);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(8, 8, 1)
+fn main(
+    @builtin(global_invocation_id) global_invocation_id: vec3<u32>,
+) {
+    let i_coord = global_invocation_id.xy;
+    let texture_size = textureDimensions(gBufferDepth);
+
+    if (!all(i_coord < texture_size)) {
+        return;
+    }
+
+    // Distinct seed from the resample pass so the tap rotation decorrelates.
+    random_initialize(vec3<u32>(i_coord, view.frame_index), vec3<u32>(0x68E31DA4u, 0xB5297A4Du, 0x1B56C4E9u));
+
+    let address = restir_reservoir_address(i_coord, texture_size.x);
+    let self_reservoir = rtxdi_unpack_reservoir(reservoir_input[address]);
+
+    var result = self_reservoir;
+
+    let surface = restir_reconstruct_surface(i_coord, texture_size);
+    if (surface.is_valid) {
+        // Blue-noise rotation for the neighbour tap pattern. Offset the STBN
+        // temporal slice so it decorrelates from the resample pass's STBN use.
+        let rotation_random = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index + 32u)).x;
+
+        result = restir_spatial_reuse(
+            self_reservoir,
+            surface.geometry,
+            surface.material,
+            surface.view_depth,
+            i_coord,
+            texture_size,
+            rotation_random,
+        );
+    }
+
+    reservoir_output[address] = rtxdi_pack_reservoir(result);
+}
+    `, [
+        chunk_restir_reconstruct_surface,
+        chunk_restir_spatial_reuse,
+        chunk_stbn_sample_vec2,
+        chunk_rtxdi_unpack_reservoir,
+        chunk_rtxdi_pack_reservoir,
+        chunk_restir_reservoir_address,
+        chunk_random,
+        chunk_random_initialize,
+    ]
+);
+
+export const shader_restir_di_spatial = ComputeShader.from({
+    label: "ReSTIR DI Spatial",
+    resources,
+    body,
+    group_size: [8, 8, 1],
+});

package/src/shade/renderer/restir/reservoir/NOTES.md

@@ -0,0 +1,6 @@
+Basic idea is to stocastically decide which lights are visible, and feed that information into shading stage
+
+References:
+https://github.com/NVIDIAGameWorks/RTXDI
+http://www.zyanidelab.com/how-to-add-thousands-of-lights-to-your-renderer/
+https://cwyman.org/presentations/2021_HPG_Productizing_ReSTIR.pdf

package/src/shade/renderer/restir/reservoir/RTXDI_PackedReservoir.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @see https://github.com/shader-slang/falcor-compile-perf-test/blob/c74eb3137dacc013537cd6cd59a178b8bf8ab5fc/source/shaders/rtxdi/RtxdiParameters.h#L140C1-L148C3
+ * @type {WebGPUStruct}
+ */
+export const RTXDI_PackedReservoir: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=RTXDI_PackedReservoir.d.ts.map

package/src/shade/renderer/restir/reservoir/RTXDI_PackedReservoir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RTXDI_PackedReservoir.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/reservoir/RTXDI_PackedReservoir.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,oCAFU,YAAY,CASnB;6BAb0B,mCAAmC"}

package/src/shade/renderer/restir/reservoir/RTXDI_PackedReservoir.js

@@ -0,0 +1,15 @@
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * @see https://github.com/shader-slang/falcor-compile-perf-test/blob/c74eb3137dacc013537cd6cd59a178b8bf8ab5fc/source/shaders/rtxdi/RtxdiParameters.h#L140C1-L148C3
+ * @type {WebGPUStruct}
+ */
+export const RTXDI_PackedReservoir = WebGPUStruct.from({
+    lightData: u32,
+    uvData: u32,
+    mVisibility: u32,
+    distanceAge: u32,
+    targetPdf: f32,
+    weight: f32
+});

package/src/shade/renderer/restir/reservoir/RTXDI_Reservoir.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This structure represents a single light reservoir that stores the weights, the sample ref,
+ * sample count (M), and visibility for reuse. It can be serialized into RTXDI_PackedReservoir for storage.
+ * @see https://github.com/shader-slang/falcor-compile-perf-test/blob/c74eb3137dacc013537cd6cd59a178b8bf8ab5fc/source/shaders/rtxdi/Reservoir.hlsli#L24C8-L24C23
+ * @type {WebGPUStruct}
+ */
+export const RTXDI_Reservoir: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=RTXDI_Reservoir.d.ts.map

package/src/shade/renderer/restir/reservoir/RTXDI_Reservoir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RTXDI_Reservoir.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/reservoir/RTXDI_Reservoir.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,8BAFU,YAAY,CAmCnB;6BAzC0B,mCAAmC"}

package/src/shade/renderer/restir/reservoir/RTXDI_Reservoir.js

@@ -0,0 +1,43 @@
+import { f32, u32, vec2i } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * This structure represents a single light reservoir that stores the weights, the sample ref,
+ * sample count (M), and visibility for reuse. It can be serialized into RTXDI_PackedReservoir for storage.
+ * @see https://github.com/shader-slang/falcor-compile-perf-test/blob/c74eb3137dacc013537cd6cd59a178b8bf8ab5fc/source/shaders/rtxdi/Reservoir.hlsli#L24C8-L24C23
+ * @type {WebGPUStruct}
+ */
+export const RTXDI_Reservoir = WebGPUStruct.from({
+
+    // Light index (bits 0..30) and validity bit (31)
+    lightData: u32,
+
+    // Sample UV encoded in 16-bit fixed point format
+    uvData: u32,
+
+    // Overloaded: represents RIS weight sum during streaming,
+    // then reservoir weight (inverse PDF) after FinalizeResampling
+    weightSum: f32,
+
+    // Target PDF of the selected sample
+    targetPdf: f32,
+
+    // Number of samples considered for this reservoir (pairwise MIS makes this a float)
+    M: f32,
+
+    // Visibility information stored in the reservoir for reuse
+    packedVisibility: u32,
+
+    // Screen-space distance between the current location of the reservoir
+    // and the location where the visibility information was generated,
+    // minus the motion vectors applied in temporal resampling.
+    // NOTE: must be a 2-component vector — the resampling/visibility chunks assign
+    // vec2<i32>(0,0) and the packed form encodes two signed 8-bit channels (x,y).
+    spatialDistance: vec2i,
+
+    // How many frames ago the visibility information was generated
+    age: u32,
+
+    // Canonical weight when using pairwise MIS (ignored except during pairwise MIS computations)
+    canonicalWeight: f32,
+});

package/src/shade/renderer/restir/reservoir/chunk_rtxdi_PackedReservoir_constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * https://github.com/shader-slang/falcor-compile-perf-test/blob/c74eb3137dacc013537cd6cd59a178b8bf8ab5fc/source/shaders/rtxdi/Reservoir.hlsli#L57C1-L72C1
+ * @type {CodeChunk}
+ */
+export const chunk_rtxdi_PackedReservoir_constants: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_rtxdi_PackedReservoir_constants.d.ts.map

package/src/shade/renderer/restir/reservoir/chunk_rtxdi_PackedReservoir_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_rtxdi_PackedReservoir_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/reservoir/chunk_rtxdi_PackedReservoir_constants.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oDAFU,SAAS,CAyBlB;0BA7ByB,oCAAoC"}

package/src/shade/renderer/restir/reservoir/chunk_rtxdi_PackedReservoir_constants.js

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * https://github.com/shader-slang/falcor-compile-perf-test/blob/c74eb3137dacc013537cd6cd59a178b8bf8ab5fc/source/shaders/rtxdi/Reservoir.hlsli#L57C1-L72C1
+ * @type {CodeChunk}
+ */
+export const chunk_rtxdi_PackedReservoir_constants = CodeChunk.from(
+    //language=WGSL
+    `
+// Encoding helper constants for RTXDI_PackedReservoir.mVisibility
+ const  RTXDI_PackedReservoir_VisibilityMask:u32 = 0x3ffff;
+ const  RTXDI_PackedReservoir_VisibilityChannelMax:u32 = 0x3f;
+ const  RTXDI_PackedReservoir_VisibilityChannelShift:u32 = 6;
+ const  RTXDI_PackedReservoir_MShift:u32 = 18;
+ const  RTXDI_PackedReservoir_MaxM:u32 = 0x3fff;
+
+// Encoding helper constants for RTXDI_PackedReservoir.distanceAge
+ const  RTXDI_PackedReservoir_DistanceChannelBits:u32 = 8;
+ const  RTXDI_PackedReservoir_DistanceXShift:u32 = 0;
+ const  RTXDI_PackedReservoir_DistanceYShift:u32 = 8;
+ const  RTXDI_PackedReservoir_AgeShift:u32 = 16;
+ const  RTXDI_PackedReservoir_MaxAge:u32 = 0xff;
+ const  RTXDI_PackedReservoir_DistanceMask:u32 = (1u << RTXDI_PackedReservoir_DistanceChannelBits) - 1;
+ const  RTXDI_PackedReservoir_MaxDistance:i32 = i32((1u << (RTXDI_PackedReservoir_DistanceChannelBits - 1u)) - 1u);
+
+// Light index helpers
+const  RTXDI_Reservoir_LightValidBit:u32 = 0x80000000;
+const  RTXDI_Reservoir_LightIndexMask:u32 = 0x7FFFFFFF;
+    `
+)