@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -1,84 +1,85 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
-import { chunk_plane_from_normal_and_point } from "../../../shader/chunk/geometry/plane/chunk_plane_from_normal_and_point.js";
-import { chunk_point_distance_above_plane } from "../../../shader/chunk/geometry/plane/chunk_point_distance_above_plane.js";
-import { chunk_is_on_screen_i32 } from "../../../shader/chunk/texture/chunk_is_on_screen_i32.js";
-import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
-import { chunk_get_bilinear_weights } from "../../../shader/chunk/texture/sample/chunk_get_bilinear_weights.js";
-import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
-
-/** Resource names are supplied by ssr_reproject_shader. Validate exactly the taps we read. */
-export const chunk_ssr_sample_history = CodeChunk.from(/* language=WGSL */ `
-struct SSRHistorySample {
-    radiance: vec4f,
-    confidence: f32,
-    age: f32,
-    short_luma: f32,
-}
-
-fn ssr_sample_history(
-    uv: vec2f, position: vec3f, normal: vec3f, roughness: f32,
-    metadata: vec2f, virtual_position: vec3f, virtual_candidate: bool, plane_tolerance: f32,
-) -> SSRHistorySample {
-    var result: SSRHistorySample;
-    if (!is_finite(uv.x) || !is_finite(uv.y) || any(uv < vec2f(0.0)) || any(uv >= vec2f(1.0))) {
-        return result;
-    }
-    let size = textureDimensions(tHistory);
-    let texel = uv * vec2f(size) - 0.5;
-    let origin = vec2i(floor(texel));
-    let weights = get_bilinear_weights(fract(texel));
-    let offsets = array<vec2i, 4>(vec2i(0,0), vec2i(1,0), vec2i(0,1), vec2i(1,1));
-    let plane = plane_from_normal_and_point(normal, position);
-    for (var i = 0; i < 4; i++) {
-        let coord = origin + offsets[i];
-        if (weights[i] <= 0.0 || !is_on_screen_i32(coord, vec2i(size))) { continue; }
-        let depth = textureLoad(tPreviousDepth, coord, 0).r;
-        if (is_background(depth)) { continue; }
-        let geometry = textureLoad(tHistoryGeometry, coord, 0);
-        if (!is_finite(geometry.x) || !is_finite(geometry.y) || !is_finite(geometry.z) || !is_finite(geometry.w)) { continue; }
-        if (dot(geometry.xyz, geometry.xyz) < 0.5) { continue; }
-        let normal_agreement = dot(normal, normalize(geometry.xyz));
-        if (normal_agreement < select(0.9, 0.995, virtual_candidate) || abs(roughness - geometry.w) > 0.08) { continue; }
-        let previous_position = project_position_from_depth(
-            texel_coordinate_to_uv(vec2f(coord), size), depth, camera_previous.view_projection_matrix_inverse);
-        let plane_distance = abs(point_distance_above_plane(previous_position, plane));
-        if (!is_finite(plane_distance) || plane_distance > plane_tolerance) { continue; }
-        let previous_metadata = textureLoad(tHistoryMetadata, coord, 0);
-        if (!is_finite(previous_metadata.x) || !is_finite(previous_metadata.y)) { continue; }
-        if (!is_finite(previous_metadata.z) || !is_finite(previous_metadata.w)) { continue; }
-        // On a rough reflector, hit/miss support is itself a stochastic sample. It is
-        // not evidence that the receiving surface or the reflected scene has moved.
-        if (roughness <= 0.2 && abs(previous_metadata.y - metadata.y) > 0.25) { continue; }
-        var support = 1.0;
-        if (virtual_candidate) {
-            if (previous_metadata.y < 0.5 || previous_metadata.x <= 0.0) { continue; }
-            // Compare reflected distance from this OLD mirror point, not from today's point.
-            let expected_distance = length(virtual_position - previous_position);
-            let distance_error = abs(previous_metadata.x - expected_distance);
-            if (distance_error > max(expected_distance * 0.1, plane_tolerance)) { continue; }
-            support = min(metadata.y, previous_metadata.y);
-        }
-        let radiance = textureLoad(tHistory, coord, 0);
-        if (!is_finite(radiance.x) || !is_finite(radiance.y) || !is_finite(radiance.z) || !is_finite(radiance.w)) { continue; }
-        let w = weights[i] * support;
-        let age = clamp(previous_metadata.z, 1.0, 128.0);
-        // Reconstruct each tap's distribution variance BEFORE interpolation.
-        // E[variance/age] * E[age] can wildly inflate noise at an age boundary.
-        result.radiance += max(radiance, vec4f(0.0)) * vec4f(w,w,w,w*age);
-        result.age += age * w;
-        result.short_luma += previous_metadata.w * w;
-        result.confidence += w;
-    }
-    if (result.confidence > 1e-6) {
-        result.radiance /= result.confidence;
-        result.age /= result.confidence;
-        result.radiance.w /= result.age;
-        result.short_luma /= result.confidence;
-    }
-    return result;
-}
-`, [chunk_project_position_from_depth, chunk_is_background, chunk_plane_from_normal_and_point,
-    chunk_point_distance_above_plane, chunk_is_on_screen_i32, chunk_texel_coordinate_to_uv,
-    chunk_get_bilinear_weights, chunk_is_finite]);
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
+import { chunk_plane_from_normal_and_point } from "../../../shader/chunk/geometry/plane/chunk_plane_from_normal_and_point.js";
+import { chunk_point_distance_above_plane } from "../../../shader/chunk/geometry/plane/chunk_point_distance_above_plane.js";
+import { chunk_is_on_screen_i32 } from "../../../shader/chunk/texture/chunk_is_on_screen_i32.js";
+import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { chunk_get_bilinear_filter_uv } from "../../../shader/chunk/texture/sample/chunk_get_bilinear_filter_uv.js";
+import { chunk_get_bilinear_weights } from "../../../shader/chunk/texture/sample/chunk_get_bilinear_weights.js";
+import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
+
+/** Resource names are supplied by ssr_reproject_shader. Validate exactly the taps we read. */
+export const chunk_ssr_sample_history = CodeChunk.from(/* language=WGSL */ `
+struct SSRHistorySample {
+    radiance: vec4f,
+    confidence: f32,
+    age: f32,
+    short_luma: f32,
+}
+
+fn ssr_sample_history(
+    uv: vec2f, position: vec3f, normal: vec3f, roughness: f32,
+    metadata: vec2f, virtual_position: vec3f, virtual_candidate: bool, plane_tolerance: f32,
+) -> SSRHistorySample {
+    var result: SSRHistorySample;
+    if (!is_finite(uv.x) || !is_finite(uv.y) || any(uv < vec2f(0.0)) || any(uv >= vec2f(1.0))) {
+        return result;
+    }
+    let size = textureDimensions(tHistory);
+    let bilinear = get_bilinear_filter_uv(uv, size);
+    let origin = vec2i(bilinear.origin);
+    let weights = get_bilinear_weights(bilinear.weights);
+    let offsets = array<vec2i, 4>(vec2i(0,0), vec2i(1,0), vec2i(0,1), vec2i(1,1));
+    let plane = plane_from_normal_and_point(normal, position);
+    for (var i = 0; i < 4; i++) {
+        let coord = origin + offsets[i];
+        if (weights[i] <= 0.0 || !is_on_screen_i32(coord, vec2i(size))) { continue; }
+        let depth = textureLoad(tPreviousDepth, coord, 0).r;
+        if (is_background(depth)) { continue; }
+        let geometry = textureLoad(tHistoryGeometry, coord, 0);
+        if (!is_finite(geometry.x) || !is_finite(geometry.y) || !is_finite(geometry.z) || !is_finite(geometry.w)) { continue; }
+        if (dot(geometry.xyz, geometry.xyz) < 0.5) { continue; }
+        let normal_agreement = dot(normal, normalize(geometry.xyz));
+        if (normal_agreement < select(0.9, 0.995, virtual_candidate) || abs(roughness - geometry.w) > 0.08) { continue; }
+        let previous_position = project_position_from_depth(
+            texel_coordinate_to_uv(vec2f(coord), size), depth, camera_previous.view_projection_matrix_inverse);
+        let plane_distance = abs(point_distance_above_plane(previous_position, plane));
+        if (!is_finite(plane_distance) || plane_distance > plane_tolerance) { continue; }
+        let previous_metadata = textureLoad(tHistoryMetadata, coord, 0);
+        if (!is_finite(previous_metadata.x) || !is_finite(previous_metadata.y)) { continue; }
+        if (!is_finite(previous_metadata.z) || !is_finite(previous_metadata.w)) { continue; }
+        // On a rough reflector, hit/miss support is itself a stochastic sample. It is
+        // not evidence that the receiving surface or the reflected scene has moved.
+        if (roughness <= 0.2 && abs(previous_metadata.y - metadata.y) > 0.25) { continue; }
+        var support = 1.0;
+        if (virtual_candidate) {
+            if (previous_metadata.y < 0.5 || previous_metadata.x <= 0.0) { continue; }
+            // Compare reflected distance from this OLD mirror point, not from today's point.
+            let expected_distance = length(virtual_position - previous_position);
+            let distance_error = abs(previous_metadata.x - expected_distance);
+            if (distance_error > max(expected_distance * 0.1, plane_tolerance)) { continue; }
+            support = min(metadata.y, previous_metadata.y);
+        }
+        let radiance = textureLoad(tHistory, coord, 0);
+        if (!is_finite(radiance.x) || !is_finite(radiance.y) || !is_finite(radiance.z) || !is_finite(radiance.w)) { continue; }
+        let w = weights[i] * support;
+        let age = clamp(previous_metadata.z, 1.0, 128.0);
+        // Reconstruct each tap's distribution variance BEFORE interpolation.
+        // E[variance/age] * E[age] can wildly inflate noise at an age boundary.
+        result.radiance += max(radiance, vec4f(0.0)) * vec4f(w,w,w,w*age);
+        result.age += age * w;
+        result.short_luma += previous_metadata.w * w;
+        result.confidence += w;
+    }
+    if (result.confidence > 1e-6) {
+        result.radiance /= result.confidence;
+        result.age /= result.confidence;
+        result.radiance.w /= result.age;
+        result.short_luma /= result.confidence;
+    }
+    return result;
+}
+`, [chunk_project_position_from_depth, chunk_is_background, chunk_plane_from_normal_and_point,
+    chunk_point_distance_above_plane, chunk_is_on_screen_i32, chunk_texel_coordinate_to_uv,
+    chunk_get_bilinear_filter_uv, chunk_get_bilinear_weights, chunk_is_finite]);

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" }],
+});