@woosh/meep-engine 3.39.0 → 3.41.0

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

@@ -0,0 +1,40 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+
+/**
+ * A miss can still contain varying GI radiance or useful history. Only a constant,
+ * stationary, zero-uncertainty neighborhood may take the denoiser's copy path.
+ * Texture names are supplied by shader_ssr_denoise_tile_classify.
+ */
+export const chunk_ssr_denoise_tile_active = CodeChunk.from(/* language=WGSL */ `
+fn ssr_denoise_tile_active(p: vec2i, history_valid: bool, jitter_delta: vec2f) -> u32 {
+    // The halo covers ordinary raster jitter, not an arbitrary jump in raster grids.
+    if (!is_finite(jitter_delta.x) || !is_finite(jitter_delta.y)
+        || any(abs(jitter_delta) > vec2f(1.0))) { return 1u; }
+    let current = textureLoad(tInput, p, 0);
+    let metadata = textureLoad(tMetadata, p, 0).rg;
+    let velocity = textureLoad(tVelocity, p, 0).rg;
+    if (!is_finite(current.x) || !is_finite(current.y) || !is_finite(current.z) || !is_finite(current.w)
+        || !is_finite(metadata.x) || !is_finite(metadata.y)
+        || !is_finite(velocity.x) || !is_finite(velocity.y)) { return 1u; }
+    // Velocity is already in INTERNAL PIXELS. Depth clipping can select a neighboring
+    // velocity; the dilated mask protects that neighbor's moving coverage too.
+    if (any(velocity != vec2f(0.0)) || current.w != 0.0 || any(metadata != vec2f(0.0))) { return 1u; }
+    if (any(current.rgb < vec3f(0.0))) { return 1u; }
+    let size = vec2i(textureDimensions(tInput));
+    // Every horizontal/vertical color boundary has an owner. The tile halo then
+    // covers both sides, including boundaries between tiles and isoluminant colors.
+    if (p.x + 1 < size.x && any(textureLoad(tInput, p + vec2i(1,0), 0).rgb != current.rgb)) { return 1u; }
+    if (p.y + 1 < size.y && any(textureLoad(tInput, p + vec2i(0,1), 0).rgb != current.rgb)) { return 1u; }
+    if (history_valid) {
+        let old = textureLoad(tHistory, p, 0);
+        let old_metadata = textureLoad(tHistoryMetadata, p, 0);
+        // Comparisons also keep invalid history active. A hard reset never loads it.
+        if (!all(old == current) || !all(old_metadata.rg == metadata)
+            || !is_finite(old_metadata.x) || !is_finite(old_metadata.z)
+            || !(old_metadata.w == rgb_to_luminance(current.rgb))) { return 1u; }
+    }
+    return 0u;
+}
+`, [chunk_is_finite, chunk_rgb_to_luminance]);

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_temporal_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.js"],"names":[],"mappings":"AAUA,gGAAgG;AAChG,sDA6HuH;0BAxI7F,uCAAuC"}
+{"version":3,"file":"chunk_ssr_temporal_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.js"],"names":[],"mappings":"AAUA,gGAAgG;AAChG,sDA0IuH;0BArJ7F,uCAAuC"}

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

@@ -1,137 +1,150 @@
-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_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
-import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
-import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
-import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
-import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
-
-/** Linear radiance accumulation. Spatial contrast and single stochastic hits are not motion. */
-export const chunk_ssr_temporal_accumulate = CodeChunk.from(/* language=WGSL */ `
-const SSR_SHORT_BLEND = 0.25;
-const SSR_SHORT_VARIANCE_SCALE = SSR_SHORT_BLEND / (2.0-SSR_SHORT_BLEND);
-
-struct SSRAccumulation {
-    radiance: vec4f,
-    age: f32,
-    short_luma: f32,
-}
-
-fn ssr_temporal_accumulate(current: vec4f, previous: vec4f, previous_age: f32,
-    previous_short_luma: f32, confidence: f32, motion_confidence: f32, st: vec2i, history_uv: vec2f) -> SSRAccumulation {
-    let old_age = clamp(previous_age, 1.0, 128.0);
-    let current_luma = rgb_to_luminance(current.rgb);
-    let previous_luma = rgb_to_luminance(previous.rgb);
-    // Alpha describes uncertainty in the accumulated mean. Recover the estimated
-    // distribution variance before judging whether a new sample is surprising.
-    let previous_variance = max(0.0, previous.w) * old_age;
-    let short_luma = mix(previous_short_luma, current_luma, SSR_SHORT_BLEND);
-    let short_delta = current_luma - previous_short_luma;
-    // Noise statistics need a short window too: long-lived variance would hide a
-    // real transition from a noisy bright reflection to a steady dark surface.
-    let sample_variance = (1.0-SSR_SHORT_BLEND) * (previous_variance + SSR_SHORT_BLEND * short_delta * short_delta);
-    // Compare two means at different time scales, normalized by sampling noise.
-    // The previous implementation compared the mean with ONE noisy sample and
-    // discarded useful history on almost every bright ray hit.
-    let short_sigma = sqrt(max(1e-6, sample_variance * SSR_SHORT_VARIANCE_SCALE));
-    let inconsistency = abs(short_luma - previous_luma) / short_sigma;
-    var reactive = smoothstep(3.0, 6.0, inconsistency);
-
-    // A 5x5 neighbourhood sees beyond the small prefilter. Persistent temporal
-    // uncertainty keeps a chance cluster of misses from clipping a valid mean to
-    // black. Real geometry and coherent lighting changes can still rectify it.
-    let size = vec2i(textureDimensions(tInput));
-    let center_normal = decode_g_buffer_normal(textureLoad(tNormal, st, 0).xy);
-    let center_depth = textureLoad(tDepth, st, 0).r;
-    let center_roughness = decode_g_buffer_roughness(textureLoad(tPBR, st, 0));
-    var first = vec3f(0.0);
-    var second = vec3f(0.0);
-    var count = 0.0;
-    var history_mean = 0.0;
-    var short_mean = 0.0;
-    var noise_sum = 0.0;
-    var history_count = 0.0;
-    let history_st = vec2i(history_uv * vec2f(size));
-    for (var y = -2; y <= 2; y++) {
-        for (var x = -2; x <= 2; x++) {
-            let p = st + vec2i(x,y);
-            if (any(p < vec2i(0)) || any(p >= size)) { continue; }
-            let normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
-            let depth = textureLoad(tDepth, p, 0).r;
-            if (is_background(depth)) { continue; }
-            let roughness = decode_g_buffer_roughness(textureLoad(tPBR, p, 0));
-            if (!(abs(roughness-center_roughness) <= 0.08)) { continue; }
-            if (dot(normal,center_normal) < 0.9 || abs(depth-center_depth) > max(1e-4, center_depth*0.02)) { continue; }
-            let c = textureLoad(tInput, p, 0).rgb;
-            first += c;
-            second += c*c;
-            count += 1.0;
-            // Compare local short- and long-term means. A moving rough reflection
-            // can change many individually low-SNR pixels coherently. One noisy
-            // pixel cannot establish that, but a matched patch can.
-            let h = history_st + vec2i(x,y);
-            if (any(h < vec2i(0)) || any(h >= size)) { continue; }
-            let old_geometry = textureLoad(tHistoryGeometry,h,0);
-            if (!(dot(old_geometry.xyz,normal) >= 0.9)) { continue; }
-            if (!(abs(old_geometry.w-roughness) <= 0.08)) { continue; }
-            // Device depths belong to different cameras. Validate the old point
-            // against the current surface in world space, as the history gather does.
-            let old_depth = textureLoad(tPreviousDepth,h,0).r;
-            if (is_background(old_depth)) { continue; }
-            let position = project_position_from_depth(texel_coordinate_to_uv(vec2f(p),vec2u(size)),depth,camera_current.view_projection_matrix_inverse);
-            let old_position = project_position_from_depth(texel_coordinate_to_uv(vec2f(h),vec2u(size)),old_depth,camera_previous.view_projection_matrix_inverse);
-            let plane_distance = abs(dot(normal,old_position-position));
-            let tolerance = max(1e-4,0.002*get_view_space_depth(depth,camera_current));
-            if (!(plane_distance <= tolerance)) { continue; }
-            let old = textureLoad(tHistory,h,0);
-            let old_metadata = textureLoad(tHistoryMetadata,h,0);
-            if (!is_finite(old.x) || !is_finite(old.y) || !is_finite(old.z) || !is_finite(old.w)
-                || !is_finite(old_metadata.z) || !is_finite(old_metadata.w)) { continue; }
-            let luma = rgb_to_luminance(c);
-            let d = luma-old_metadata.w;
-            history_mean += rgb_to_luminance(old.rgb);
-            short_mean += mix(old_metadata.w,luma,SSR_SHORT_BLEND);
-            noise_sum += (1.0-SSR_SHORT_BLEND) * (max(0.0,old.w)*clamp(old_metadata.z,1.0,128.0) + SSR_SHORT_BLEND*d*d);
-            history_count += 1.0;
-        }
-    }
-    if (history_count >= 9.0) {
-        // The 3x3 prefilter correlates adjacent samples: use a conservative nine
-        // taps per independent observation instead of claiming 25 independent rays.
-        let sigma = sqrt(max(1e-6,noise_sum*SSR_SHORT_VARIANCE_SCALE*9.0));
-        reactive = max(reactive,smoothstep(3.0,6.0,abs(short_mean-history_mean)/sigma));
-    }
-    // Blend update rates, not history lengths: halfway from 128 to two frames
-    // would still retain ~98% history and barely respond to a detected change.
-    let mature_age = min(128.0, old_age * confidence + 1.0);
-    var age = 1.0 / mix(1.0/mature_age, 0.5, reactive);
-    let mean = first / max(1.0,count);
-    // The carried variance is in luminance units. Expand RGB bounds along the
-    // history color, otherwise saturated blue gets only 7.22% of its RGB sigma
-    // and a normal stochastic miss can erase an already converged reflection.
-    let noise_color = select(vec3f(1.0),previous.rgb/max(previous_luma,1e-6),previous_luma > 1e-6);
-    let deviation = sqrt(max(noise_color*noise_color*previous_variance, second / max(1.0,count) - mean*mean));
-    let gamma = mix(1.5, 4.0, motion_confidence);
-    let clipped = clamp(previous.rgb, max(vec3f(0.0),mean-gamma*deviation), mean+gamma*deviation);
-    // Once history is outside even the noise-expanded box, it is no longer a
-    // well-supported long-term estimate. Do not leave it pinned to a clipped edge.
-    let rectified = any(abs(previous.rgb-clipped) > vec3f(1e-5));
-    if (rectified) { age = min(age, 2.0); }
-    // Confidence can force a much larger current contribution than 1/age.
-    // Carry that actual update rate into the age/variance pair too; otherwise a
-    // half-current blend can claim the uncertainty of a 65-frame accumulation.
-    age = min(age, 1.0 / max(1e-6, 1.0-saturate(confidence)));
-    let weight = min(saturate(confidence), 1.0 - 1.0/age);
-    let color = mix(current.rgb, clipped, weight);
-    var result: SSRAccumulation;
-    // Post-spatial passes receive uncertainty of the mean, rather than the raw
-    // sample distribution or the resolve pass's within-ray variance.
-    result.radiance = vec4f(color, min(65504.0,sample_variance/age));
-    result.age = age;
-    result.short_luma = select(short_luma, rgb_to_luminance(color), rectified);
-    return result;
-}
-`, [chunk_rgb_to_luminance, chunk_decode_g_buffer_normal, chunk_is_finite, chunk_decode_g_buffer_roughness,
-    chunk_project_position_from_depth, chunk_texel_coordinate_to_uv, chunk_get_view_space_depth, chunk_is_background]);
+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_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
+import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
+import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
+
+/** Linear radiance accumulation. Spatial contrast and single stochastic hits are not motion. */
+export const chunk_ssr_temporal_accumulate = CodeChunk.from(/* language=WGSL */ `
+const SSR_SHORT_BLEND = 0.25;
+const SSR_SHORT_VARIANCE_SCALE = SSR_SHORT_BLEND / (2.0-SSR_SHORT_BLEND);
+
+struct SSRAccumulation {
+    radiance: vec4f,
+    age: f32,
+    short_luma: f32,
+}
+
+fn ssr_temporal_accumulate(current: vec4f, previous: vec4f, previous_age: f32,
+    previous_short_luma: f32, confidence: f32, motion_confidence: f32, st: vec2i, history_uv: vec2f,
+    constant_neighborhood: bool) -> SSRAccumulation {
+    let old_age = clamp(previous_age, 1.0, 128.0);
+    let current_luma = rgb_to_luminance(current.rgb);
+    let previous_luma = rgb_to_luminance(previous.rgb);
+    // Alpha describes uncertainty in the accumulated mean. Recover the estimated
+    // distribution variance before judging whether a new sample is surprising.
+    let previous_variance = max(0.0, previous.w) * old_age;
+    let short_luma = mix(previous_short_luma, current_luma, SSR_SHORT_BLEND);
+    let short_delta = current_luma - previous_short_luma;
+    // Noise statistics need a short window too: long-lived variance would hide a
+    // real transition from a noisy bright reflection to a steady dark surface.
+    let sample_variance = (1.0-SSR_SHORT_BLEND) * (previous_variance + SSR_SHORT_BLEND * short_delta * short_delta);
+    // Compare two means at different time scales, normalized by sampling noise.
+    // The previous implementation compared the mean with ONE noisy sample and
+    // discarded useful history on almost every bright ray hit.
+    let short_sigma = sqrt(max(1e-6, sample_variance * SSR_SHORT_VARIANCE_SCALE));
+    let inconsistency = abs(short_luma - previous_luma) / short_sigma;
+    var reactive = smoothstep(3.0, 6.0, inconsistency);
+
+    // A 5x5 neighbourhood sees beyond the small prefilter. Persistent temporal
+    // uncertainty keeps a chance cluster of misses from clipping a valid mean to
+    // black. Real geometry and coherent lighting changes can still rectify it.
+    let size = vec2i(textureDimensions(tInput));
+    let center_normal = decode_g_buffer_normal(textureLoad(tNormal, st, 0).xy);
+    let center_depth = textureLoad(tDepth, st, 0).r;
+    let center_roughness = decode_g_buffer_roughness(textureLoad(tPBR, st, 0));
+    var first = vec3f(0.0);
+    var second = vec3f(0.0);
+    var count = 0.0;
+    var history_mean = 0.0;
+    var short_mean = 0.0;
+    var noise_sum = 0.0;
+    var history_count = 0.0;
+    let history_st = vec2i(history_uv * vec2f(size));
+    // The classifier covers the neighborhood; the ordinary history gather still
+    // validates geometry, depth, roughness, jitter and confidence. Keep the shared
+    // age/variance/blend calculation below so skipped tiles retain mature history.
+    // A changed or interpolated sample falls back to the full statistics path.
+    let constant = constant_neighborhood && current.w == 0.0 && all(current == previous)
+        && previous_short_luma == current_luma;
+    if (constant) {
+        first = current.rgb;
+        second = current.rgb * current.rgb;
+        count = 1.0;
+    } else {
+        for (var y = -2; y <= 2; y++) {
+            for (var x = -2; x <= 2; x++) {
+                let p = st + vec2i(x,y);
+                if (any(p < vec2i(0)) || any(p >= size)) { continue; }
+                let normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+                let depth = textureLoad(tDepth, p, 0).r;
+                if (is_background(depth)) { continue; }
+                let roughness = decode_g_buffer_roughness(textureLoad(tPBR, p, 0));
+                if (!(abs(roughness-center_roughness) <= 0.08)) { continue; }
+                if (dot(normal,center_normal) < 0.9 || abs(depth-center_depth) > max(1e-4, center_depth*0.02)) { continue; }
+                let c = textureLoad(tInput, p, 0).rgb;
+                first += c;
+                second += c*c;
+                count += 1.0;
+                // Compare local short- and long-term means. A moving rough reflection
+                // can change many individually low-SNR pixels coherently. One noisy
+                // pixel cannot establish that, but a matched patch can.
+                let h = history_st + vec2i(x,y);
+                if (any(h < vec2i(0)) || any(h >= size)) { continue; }
+                let old_geometry = textureLoad(tHistoryGeometry,h,0);
+                if (!(dot(old_geometry.xyz,normal) >= 0.9)) { continue; }
+                if (!(abs(old_geometry.w-roughness) <= 0.08)) { continue; }
+                // Device depths belong to different cameras. Validate the old point
+                // against the current surface in world space, as the history gather does.
+                let old_depth = textureLoad(tPreviousDepth,h,0).r;
+                if (is_background(old_depth)) { continue; }
+                let position = project_position_from_depth(texel_coordinate_to_uv(vec2f(p),vec2u(size)),depth,camera_current.view_projection_matrix_inverse);
+                let old_position = project_position_from_depth(texel_coordinate_to_uv(vec2f(h),vec2u(size)),old_depth,camera_previous.view_projection_matrix_inverse);
+                let plane_distance = abs(dot(normal,old_position-position));
+                let tolerance = max(1e-4,0.002*get_view_space_depth(depth,camera_current));
+                if (!(plane_distance <= tolerance)) { continue; }
+                let old = textureLoad(tHistory,h,0);
+                let old_metadata = textureLoad(tHistoryMetadata,h,0);
+                if (!is_finite(old.x) || !is_finite(old.y) || !is_finite(old.z) || !is_finite(old.w)
+                    || !is_finite(old_metadata.z) || !is_finite(old_metadata.w)) { continue; }
+                let luma = rgb_to_luminance(c);
+                let d = luma-old_metadata.w;
+                history_mean += rgb_to_luminance(old.rgb);
+                short_mean += mix(old_metadata.w,luma,SSR_SHORT_BLEND);
+                noise_sum += (1.0-SSR_SHORT_BLEND) * (max(0.0,old.w)*clamp(old_metadata.z,1.0,128.0) + SSR_SHORT_BLEND*d*d);
+                history_count += 1.0;
+            }
+        }
+    }
+    if (history_count >= 9.0) {
+        // The 3x3 prefilter correlates adjacent samples: use a conservative nine
+        // taps per independent observation instead of claiming 25 independent rays.
+        let sigma = sqrt(max(1e-6,noise_sum*SSR_SHORT_VARIANCE_SCALE*9.0));
+        reactive = max(reactive,smoothstep(3.0,6.0,abs(short_mean-history_mean)/sigma));
+    }
+    // Blend update rates, not history lengths: halfway from 128 to two frames
+    // would still retain ~98% history and barely respond to a detected change.
+    let mature_age = min(128.0, old_age * confidence + 1.0);
+    var age = 1.0 / mix(1.0/mature_age, 0.5, reactive);
+    let mean = first / max(1.0,count);
+    // The carried variance is in luminance units. Expand RGB bounds along the
+    // history color, otherwise saturated blue gets only 7.22% of its RGB sigma
+    // and a normal stochastic miss can erase an already converged reflection.
+    let noise_color = select(vec3f(1.0),previous.rgb/max(previous_luma,1e-6),previous_luma > 1e-6);
+    let deviation = sqrt(max(noise_color*noise_color*previous_variance, second / max(1.0,count) - mean*mean));
+    let gamma = mix(1.5, 4.0, motion_confidence);
+    let clipped = clamp(previous.rgb, max(vec3f(0.0),mean-gamma*deviation), mean+gamma*deviation);
+    // Once history is outside even the noise-expanded box, it is no longer a
+    // well-supported long-term estimate. Do not leave it pinned to a clipped edge.
+    let rectified = any(abs(previous.rgb-clipped) > vec3f(1e-5));
+    if (rectified) { age = min(age, 2.0); }
+    // Confidence can force a much larger current contribution than 1/age.
+    // Carry that actual update rate into the age/variance pair too; otherwise a
+    // half-current blend can claim the uncertainty of a 65-frame accumulation.
+    age = min(age, 1.0 / max(1e-6, 1.0-saturate(confidence)));
+    let weight = min(saturate(confidence), 1.0 - 1.0/age);
+    let color = mix(current.rgb, clipped, weight);
+    var result: SSRAccumulation;
+    // Post-spatial passes receive uncertainty of the mean, rather than the raw
+    // sample distribution or the resolve pass's within-ray variance.
+    result.radiance = vec4f(color, min(65504.0,sample_variance/age));
+    result.age = age;
+    result.short_luma = select(short_luma, rgb_to_luminance(color), rectified);
+    return result;
+}
+`, [chunk_rgb_to_luminance, chunk_decode_g_buffer_normal, chunk_is_finite, chunk_decode_g_buffer_roughness,
+    chunk_project_position_from_depth, chunk_texel_coordinate_to_uv, chunk_get_view_space_depth, chunk_is_background]);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_ssr_denoise_tile_classify.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/shader_ssr_denoise_tile_classify.js"],"names":[],"mappings":"AAoBA,6DAuBG;8BA1C2B,+BAA+B"}

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

@@ -0,0 +1,44 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { u32, vec2f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { chunk_ssr_denoise_tile_active } from "./chunk_ssr_denoise_tile_active.js";
+import { SSR_DENOISE_TILE_SIZE } from "./SSR_DENOISE_TILE_SIZE.js";
+
+const settings = WebGPUStruct.from({ history_valid: u32, jitter_delta: vec2f });
+const resources = new ShaderResourceSetDescriptor();
+resources.setImmediate("settings", settings);
+resources.createGroup()
+    .addTexture("tInput")
+    .addTexture("tMetadata", "unfilterable-float")
+    .addTexture("tHistory")
+    .addTexture("tHistoryMetadata", "unfilterable-float")
+    .addTexture("tVelocity")
+    .addStorageTexture("tTiles", "r32uint", "2d", "write-only");
+
+const count = SSR_DENOISE_TILE_SIZE ** 2;
+export const shader_ssr_denoise_tile_classify = ComputeShader.from({
+    label: "SSR / classify denoise tiles",
+    resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+var<workgroup> coverage: array<u32, ${count}>;
+
+@compute @workgroup_size(${SSR_DENOISE_TILE_SIZE}, ${SSR_DENOISE_TILE_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3u,
+    @builtin(workgroup_id) tile: vec3u, @builtin(local_invocation_index) lane: u32) {
+    var flag = 0u;
+    if (all(id.xy < textureDimensions(tInput))) {
+        flag = ssr_denoise_tile_active(vec2i(id.xy), settings.history_valid != 0u, settings.jitter_delta);
+    }
+    // Tail lanes still participate in every barrier and contribute the identity.
+    coverage[lane] = flag;
+    workgroupBarrier();
+    for (var stride = ${count / 2}u; stride > 0u; stride >>= 1u) {
+        if (lane < stride) { coverage[lane] |= coverage[lane + stride]; }
+        workgroupBarrier();
+    }
+    if (lane == 0u) { textureStore(tTiles, vec2i(tile.xy), vec4u(coverage[0], 0u, 0u, 0u)); }
+}
+`, [settings.declaration_chunk, chunk_ssr_denoise_tile_active]),
+});

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

@@ -0,0 +1,5 @@
+export const SSR_DENOISE_TILE_HALO: number;
+/** Expand integer coverage over the complete denoising footprint. */
+export const shader_ssr_denoise_tile_dilate: ImageShader;
+import { ImageShader } from "../../shader/ImageShader.js";
+//# sourceMappingURL=shader_ssr_denoise_tile_dilate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_ssr_denoise_tile_dilate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/shader_ssr_denoise_tile_dilate.js"],"names":[],"mappings":"AASA,2CAA4F;AAI5F,qEAAqE;AACrE,yDAoBG;4BAjCyB,6BAA6B"}

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

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_is_on_screen_i32 } from "../../shader/chunk/texture/chunk_is_on_screen_i32.js";
+import { SSR_DENOISE_TILE_SIZE } from "./SSR_DENOISE_TILE_SIZE.js";
+
+// Pre-spatial (1), temporal statistics (2), post-spatial (2+4), and raster jitter
+// (1) can influence an output ten internal pixels away. One 8-pixel tile is too small.
+export const SSR_DENOISE_TILE_HALO = Math.ceil((1 + 2 + 2 + 4 + 1) / SSR_DENOISE_TILE_SIZE);
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addTexture("tTiles", "uint");
+
+/** Expand integer coverage over the complete denoising footprint. */
+export const shader_ssr_denoise_tile_dilate = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "SSR / dilate denoise tiles",
+        resources,
+        body: CodeChunk.from(/* language=WGSL */ `
+@fragment fn main(@builtin(position) coord: vec4f) -> @location(0) u32 {
+    let p = vec2i(coord.xy);
+    let size = vec2i(textureDimensions(tTiles));
+    var coverage = 0u;
+    for (var y = -${SSR_DENOISE_TILE_HALO}; y <= ${SSR_DENOISE_TILE_HALO}; y++) {
+        for (var x = -${SSR_DENOISE_TILE_HALO}; x <= ${SSR_DENOISE_TILE_HALO}; x++) {
+            let q = p + vec2i(x,y);
+            if (is_on_screen_i32(q,size)) { coverage |= textureLoad(tTiles,q,0).r; }
+        }
+    }
+    return coverage;
+}
+`, [chunk_is_on_screen_i32]),
+    }),
+    targets: [{ format: "r32uint" }],
+});

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

@@ -0,0 +1,26 @@
+/**
+ * Frame-local coverage; allocation, lifetime, dependencies and timing belong to the graph.
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {ArrayLike<number>} options.resolution Internal SSR resolution
+ * @param {number} options.input
+ * @param {number} options.metadata
+ * @param {number} options.history
+ * @param {number} options.history_metadata
+ * @param {number} options.velocity
+ * @param {boolean} options.history_valid
+ * @param {ArrayLike<number>} options.jitter_delta
+ * @returns {number} Dilated tile mask
+ */
+export function ssr_graph_denoise_tiles({ graph, resolution, input, metadata, history, history_metadata, velocity, history_valid, jitter_delta }: {
+    graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    resolution: ArrayLike<number>;
+    input: number;
+    metadata: number;
+    history: number;
+    history_metadata: number;
+    velocity: number;
+    history_valid: boolean;
+    jitter_delta: ArrayLike<number>;
+}): number;
+//# sourceMappingURL=ssr_graph_denoise_tiles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ssr_graph_denoise_tiles.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_graph_denoise_tiles.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACtD,UAAU,EAArC,UAAU,MAAM,CAAC;IACD,KAAK,EAArB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,OAAO,EAAvB,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACU,QAAQ,EAAxB,MAAM;IACW,aAAa,EAA9B,OAAO;IACoB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf,MAAM,CAsBlB"}

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

@@ -0,0 +1,42 @@
+import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
+import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
+import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
+import { SSR_DENOISE_TILE_SIZE } from "./SSR_DENOISE_TILE_SIZE.js";
+import { shader_ssr_denoise_tile_classify } from "./shader_ssr_denoise_tile_classify.js";
+import { shader_ssr_denoise_tile_dilate } from "./shader_ssr_denoise_tile_dilate.js";
+
+/**
+ * Frame-local coverage; allocation, lifetime, dependencies and timing belong to the graph.
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {ArrayLike<number>} options.resolution Internal SSR resolution
+ * @param {number} options.input
+ * @param {number} options.metadata
+ * @param {number} options.history
+ * @param {number} options.history_metadata
+ * @param {number} options.velocity
+ * @param {boolean} options.history_valid
+ * @param {ArrayLike<number>} options.jitter_delta
+ * @returns {number} Dilated tile mask
+ */
+export function ssr_graph_denoise_tiles({ graph, resolution, input, metadata, history,
+    history_metadata, velocity, history_valid, jitter_delta }) {
+    const tile_resolution = [Math.ceil(resolution[0] / SSR_DENOISE_TILE_SIZE), Math.ceil(resolution[1] / SSR_DENOISE_TILE_SIZE)];
+    const { tTiles } = graph_compute_pass({
+        graph,
+        shader: shader_ssr_denoise_tile_classify,
+        group_count: [...tile_resolution, 1],
+        bindings: {
+            tInput: input, tMetadata: metadata, tHistory: history,
+            tHistoryMetadata: history_metadata, tVelocity: velocity,
+            settings: { history_valid: history_valid ? 1 : 0, jitter_delta },
+            tTiles: TextureResourceDescriptor.from({
+                resolution: tile_resolution, dimension: "2d", format: "r32uint",
+                usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
+            }),
+        },
+    });
+    const [tiles] = graph_image_pass({ graph, shader: shader_ssr_denoise_tile_dilate,
+        output_resolution: tile_resolution, inputs: { tTiles } });
+    return tiles;
+}

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

@@ -1,3 +1,4 @@
 export const ssr_reproject_shader: ImageShader;
+export const ssr_reproject_tile_shader: ImageShader;
 import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=ssr_reproject_shader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ssr_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js"],"names":[],"mappings":"AAqGA,+CAGG;4BAlGyB,6BAA6B"}
+{"version":3,"file":"ssr_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js"],"names":[],"mappings":"AA+GA,+CAAmE;AACnE,oDAAuE;4BA1G3C,6BAA6B"}