@woosh/meep-engine 3.17.2 → 3.18.0

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

@@ -0,0 +1,70 @@
+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,
+}
+
+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).rg;
+        if (!is_finite(previous_metadata.x) || !is_finite(previous_metadata.y)) { continue; }
+        // A source/support transition must not preserve the previous, unrelated reflection.
+        if (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;
+        result.radiance += max(radiance, vec4f(0.0)) * w;
+        result.confidence += w;
+    }
+    if (result.confidence > 1e-6) { result.radiance /= 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]);

package/src/shade/renderer/postprocess/ssr/resolve/build_ssr_resolve_shader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Compose the shared SSR hit resolve with a mode's GI sampling functions.
+ * sample_radiance defines ssr_sample_radiance(position, normal, view_direction, roughness, coord).
+ * Optional sample_hit_irradiance defines ssr_sample_hit_irradiance(position, normal, direction).
+ *
+ * @param {object} options
+ * @param {string} options.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} options.resources GI resources
+ * @param {CodeChunk} options.sample_radiance
+ * @param {CodeChunk} [options.sample_hit_irradiance]
+ * @returns {ImageShader}
+ */
+export function build_ssr_resolve_shader({ label, resources, sample_radiance, sample_hit_irradiance }: {
+    label: string;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    sample_radiance: CodeChunk;
+    sample_hit_irradiance?: CodeChunk;
+}): ImageShader;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shader/ImageShader.js";
+//# sourceMappingURL=build_ssr_resolve_shader.d.ts.map

package/src/shade/renderer/postprocess/ssr/resolve/build_ssr_resolve_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/build_ssr_resolve_shader.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;GAWG;AACH;IAN2B,KAAK,EAArB,MAAM;IACiG,SAAS,EAAhH,OAAO,yDAAyD,EAAE,2BAA2B;IAC1E,eAAe,EAAlC,SAAS;IACW,qBAAqB,GAAzC,SAAS;IACP,WAAW,CAiUvB;0BAxVyB,uCAAuC;4BACrC,gCAAgC"}

package/src/shade/renderer/postprocess/ssr/resolve/build_ssr_resolve_shader.js

@@ -0,0 +1,363 @@
+import { chunk_ssr_metadata } from "../chunk_ssr_metadata.js";
+import { chunk_is_on_screen_i32 } from "../../../shader/chunk/texture/chunk_is_on_screen_i32.js";
+import { SamplerDescriptor } from "../../../../descriptor/texture/SamplerDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { chunk_direction_world_to_view } from "../../../shader/chunk/camera/chunk_direction_world_to_view.js";
+import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_screen_coordinate_to_view } from "../../../shader/chunk/camera/chunk_screen_coordinate_to_view.js";
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_rgb_to_YCoCg } from "../../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
+import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
+import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
+import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import { chunk_murmur3_vec3u } from "../../../shader/chunk/random/murmur/chunk_murmur3_vec3u.js";
+import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shader/ImageShader.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { chunk_ssr_hit_unpack } from "../chunk_ssr_hit_unpack.js";
+import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
+import { chunk_get_neighbour_weight } from "./chunk_get_neighbour_weight.js";
+import { chunk_get_ray_mip_level } from "./chunk_get_ray_mip_level.js";
+import { chunk_reconstruct_pdf } from "./chunk_reconstruct_pdf.js";
+
+const RESOLVE_UNIFORMS = WebGPUStruct.from({
+    frame_index: u32,
+});
+
+/**
+ * Compose the shared SSR hit resolve with a mode's GI sampling functions.
+ * sample_radiance defines ssr_sample_radiance(position, normal, view_direction, roughness, coord).
+ * Optional sample_hit_irradiance defines ssr_sample_hit_irradiance(position, normal, direction).
+ *
+ * @param {object} options
+ * @param {string} options.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} options.resources GI resources
+ * @param {CodeChunk} options.sample_radiance
+ * @param {CodeChunk} [options.sample_hit_irradiance]
+ * @returns {ImageShader}
+ */
+export function build_ssr_resolve_shader({ label, resources, sample_radiance, sample_hit_irradiance }) {
+
+    // per-pass, four bytes, read-only: immediate data rather than a uniform buffer
+    resources.setImmediate("settings", RESOLVE_UNIFORMS);
+    resources.createGroup()
+        .addTexture("tTrace", "uint")
+        .addTexture("tDepth")
+        .addTexture("tPBR")
+        .addTexture("tNormal", "uint")
+        .addTexture("tColor", "float")
+        .addTexture("tAlbedoAO", "unfilterable-float")
+        .addSampler("sLinear", "filtering", SamplerDescriptor.from({
+            magFilter: "linear",
+            mipmapFilter: "linear",
+            addressModeU: "clamp-to-edge",
+            addressModeV: "clamp-to-edge",
+        }))
+        .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    ;
+
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+// optimized 7x7 neighbourhood offsets. Optimized for noise diffusion and TAA artifact avoidance
+const NEIGHBOR_OFFSETS = array<vec2<i32>, 48>(
+    vec2<i32>(2, -3),
+    vec2<i32>(3, -1),
+    vec2<i32>(0, -2),
+    vec2<i32>(1, -3),
+    vec2<i32>(3, 0),
+    vec2<i32>(2, -1),
+    vec2<i32>(3, -2),
+    vec2<i32>(2, 2),
+    vec2<i32>(3, 1),
+    vec2<i32>(1, 3),
+    vec2<i32>(3, 3),
+    vec2<i32>(0, 2),
+    vec2<i32>(2, 1),
+    vec2<i32>(1, -1),
+    vec2<i32>(3, -3),
+    vec2<i32>(2, -2),
+    vec2<i32>(0, -3),
+    vec2<i32>(1, 0),
+    vec2<i32>(-2, -1),
+    vec2<i32>(-3, -2),
+    vec2<i32>(-1, -3),
+    vec2<i32>(-3, 1),
+    vec2<i32>(-2, 0),
+    vec2<i32>(-3, -1),
+    vec2<i32>(-3, 2),
+    vec2<i32>(-1, 1),
+    vec2<i32>(-2, 3),
+    vec2<i32>(0, 3),
+    vec2<i32>(1, 2),
+    vec2<i32>(-1, 0),
+    vec2<i32>(-3, 3),
+    vec2<i32>(-2, 2),
+    vec2<i32>(0, 1),
+    vec2<i32>(-1, 3),
+    vec2<i32>(2, 3),
+    vec2<i32>(3, 2),
+    vec2<i32>(1, 1),
+    vec2<i32>(2, 0),
+    vec2<i32>(0, -1),
+    vec2<i32>(-1, 2),
+    vec2<i32>(-2, 1),
+    vec2<i32>(-3, 0),
+    vec2<i32>(-2, -2),
+    vec2<i32>(-1, -1),
+    vec2<i32>(-3, -3),
+    vec2<i32>(1, -2),
+    vec2<i32>(-2, -3),
+    vec2<i32>(-1, -2),
+);
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> SSRResolveOutput {
+
+    let coord_i = vec2<i32>(coord.xy);
+
+    let texel_depth = textureLoad(tDepth, coord_i, 0 ).r;
+
+    let this_pbr = textureLoad(tPBR, coord_i, 0);
+    let this_roughness = decode_g_buffer_roughness(this_pbr);
+
+    let this_normal_ws = decode_g_buffer_normal( textureLoad(tNormal, coord_i, 0).xy );
+    let this_normal_vs = direction_world_to_view(this_normal_ws, camera);
+
+    let this_position_vs = screen_coordinate_to_view(vec2u(coord_i), tDepth, camera);
+    let view_direction_vs = normalize(-this_position_vs);
+
+    let render_resolution = textureDimensions(tColor,0).xy;
+
+    let tan_half_fov = camera.device_depth_to_view_space.w;
+    let focal_length_px = f32(render_resolution.y) / (2.0 * tan_half_fov);
+
+    let trace_texel = textureLoad(tTrace, coord_i, 0);
+
+    let this_hit = ssr_hit_unpack(trace_texel.xy);
+
+
+    let this_hit_uv = texel_coordinate_to_uv(vec2f(this_hit.position.xy), render_resolution);
+    var this_hit_position_vs = this_position_vs + this_normal_vs;
+    var this_hit_normal_ws = this_normal_ws;
+    var this_hit_color_sample = vec3f(0.0);
+    var this_confidence = 0.0;
+    if (this_hit.confidence > 0.0 && is_on_screen_i32(vec2i(this_hit.position), vec2i(render_resolution))) {
+        let hit_depth = textureLoad(tDepth, this_hit.position, 0).r;
+        if (!is_background(hit_depth)) {
+            let candidate_position = screen_coordinate_to_view(this_hit.position, tDepth, camera);
+            let candidate_distance = length(candidate_position - this_position_vs);
+            if (is_finite(candidate_distance) && candidate_distance > 1e-6) {
+                this_hit_position_vs = candidate_position;
+                this_hit_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, this_hit.position, 0).xy);
+                let hit_normal_vs = direction_world_to_view(this_hit_normal_ws, camera);
+                let mip = get_ray_mip_level(this_position_vs, this_hit_position_vs, hit_normal_vs, this_roughness, focal_length_px);
+                this_hit_color_sample = textureSampleLevel(tColor, sLinear, this_hit_uv, mip).rgb;
+                this_confidence = this_hit.confidence;
+            }
+        }
+    }
+    let this_hit_normal_vs = direction_world_to_view(this_hit_normal_ws, camera);
+    let this_weight = this_confidence;
+    var weight_sum = this_weight;
+    var max_confidence = this_confidence;
+    var distance_moments = ssr_distance_moments(length(this_hit_position_vs - this_position_vs), 1.0, this_weight);
+
+    let this_hit_luma = rgb_to_luminance(this_hit_color_sample);
+
+    var result = this_hit_color_sample * this_weight;
+    // weight the seed like every neighbour tap — both accumulators divide by weight_sum
+    var result_luma_moment2 = this_hit_luma * this_hit_luma * this_weight;
+
+    const NEIGHBOUR_SAMPLE_COUNT = 4;
+
+    let hash_seed = murmur3_vec3u(vec3u(vec2u(coord_i), settings.frame_index));
+
+    for(var i = 0u; i < NEIGHBOUR_SAMPLE_COUNT; i++){
+
+        let heighbour_index = ( hash_seed + i ) % 48;
+
+        let neighbour_coord = coord_i + NEIGHBOR_OFFSETS[heighbour_index];
+        if (!is_on_screen_i32(neighbour_coord, vec2i(render_resolution))) { continue; }
+
+        let neighbour_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, neighbour_coord, 0).xy);
+        let neighbour_normal_vs = direction_world_to_view(neighbour_normal_ws, camera);
+
+        let neighbour_pbr = textureLoad(tPBR, neighbour_coord, 0);
+        let neighbour_roughness = decode_g_buffer_roughness(neighbour_pbr);
+
+        let sample_hit = ssr_hit_unpack(textureLoad(tTrace, neighbour_coord, 0).xy);
+
+        if (sample_hit.confidence <= 0.0 || !is_on_screen_i32(vec2i(sample_hit.position), vec2i(render_resolution))) { continue; }
+        // reconstruct ray hit position
+        let sample_hit_depth = textureLoad(tDepth, sample_hit.position, 0).r;
+        if (is_background(sample_hit_depth)) { continue; }
+        let sample_hit_uv = texel_coordinate_to_uv(vec2f(sample_hit.position), render_resolution);
+        let sample_hit_position_vs = project_position_from_depth(
+            sample_hit_uv,
+            sample_hit_depth,
+            camera.projection_matrix_inverse,
+        );
+
+        let sample_distance = length(sample_hit_position_vs - this_position_vs);
+        if (!is_finite(sample_distance) || sample_distance <= 1e-6) { continue; }
+        let sample_direction = (sample_hit_position_vs - this_position_vs) / sample_distance;
+
+        // check visibility
+        let sample_hit_normal_ws = decode_g_buffer_normal( textureLoad(tNormal, sample_hit.position.xy, 0).xy );
+        let sample_hit_normal_vs = direction_world_to_view(sample_hit_normal_ws, camera);
+
+        let ray_hit_valid = step( 0, dot(-sample_direction, sample_hit_normal_vs));
+        let ray_cast_valid = step( 0, dot(sample_direction, this_normal_vs) );
+
+        // NOTE: we assume that visibility between the center sample and the neighbour is the same. This is incorrect, but thanks to normal visibility weighing and BRDF weighing - it's not noticeable in practice.
+        // technically view direction for the neighbour is different, but it's close enough as an approximation
+        let neighbour_view_direction = view_direction_vs;
+
+        let neighbour_position_vs = screen_coordinate_to_view(
+            vec2u(neighbour_coord),
+            tDepth,
+            camera,
+        );
+        let neighbour_distance = length(sample_hit_position_vs - neighbour_position_vs);
+        if (!is_finite(neighbour_distance) || neighbour_distance <= 1e-6) { continue; }
+        let neighbour_ray_direction = (sample_hit_position_vs - neighbour_position_vs) / neighbour_distance;
+
+        // reconstruct PDF for the neighbouring ray
+        // we need this to weigh the neighbour
+        let sample_pdf = reconstruct_pdf(
+            neighbour_normal_vs,
+            neighbour_view_direction,
+            neighbour_ray_direction,
+            neighbour_roughness
+        );
+
+        let sample_visibility = ray_cast_valid * ray_hit_valid;
+        let confidence_visible = sample_hit.confidence * sample_visibility;
+
+        let normalization_weight = get_neighbour_weight(
+            sample_pdf,
+            sample_direction,
+            view_direction_vs,
+            this_normal_vs,
+            this_roughness,
+        );
+
+        let weight = confidence_visible * normalization_weight;
+        if (!is_finite(weight) || weight <= 0.0) { continue; }
+        max_confidence = max(max_confidence, confidence_visible);
+        distance_moments += ssr_distance_moments(sample_distance, 1.0, weight);
+
+        weight_sum += weight;
+
+        let sample_mip = get_ray_mip_level(
+            neighbour_position_vs,
+            sample_hit_position_vs,
+            sample_hit_normal_vs,
+            neighbour_roughness,
+            focal_length_px,
+        );
+
+        let sample_color = textureSampleLevel(tColor, sLinear, sample_hit_uv, sample_mip).rgb;
+
+        result += sample_color * weight;
+
+        let sample_luma = rgb_to_luminance(sample_color);
+
+        // track second moment for variance
+        result_luma_moment2 += sample_luma * sample_luma * weight;
+    }
+
+    if(weight_sum < 1e-5){
+        // no valid samples,
+
+        // TODO search further
+    }
+
+    if(weight_sum > 1e-5 ){
+        // only normalize if we got some valid samples
+        result /= weight_sum;
+        result_luma_moment2 /= weight_sum;
+    }
+
+    let view_direction_ws = ( camera.view_matrix_inverse * vec4(view_direction_vs, 0.0) ).xyz;
+    let this_position_ws = v3_matrix4_project( this_position_vs, camera.view_matrix_inverse );
+
+
+    ${sample_hit_irradiance === undefined ? '' : `
+    if (this_confidence > 0.05) {
+        let this_hit_position_ws = v3_matrix4_project(this_hit_position_vs, camera.view_matrix_inverse);
+        let this_hit_direction_ws = normalize(this_hit_position_ws - this_position_ws);
+        let hit_irradiance = ssr_sample_hit_irradiance(
+            this_hit_position_ws, this_hit_normal_ws, this_hit_direction_ws,
+        );
+        let this_hit_albedo = textureLoad(tAlbedoAO, this_hit.position, 0).rgb;
+        result += this_hit_albedo * hit_irradiance * RECIPROCAL_PI;
+    }
+    `}
+
+    let gi_radiance = ssr_sample_radiance(
+        this_position_ws, this_normal_ws, view_direction_ws, this_roughness, vec2u(coord_i),
+    );
+
+    // NOTE: we don't apply Fresnel here because it's added after denoising
+
+    let color = mix(gi_radiance, result, max_confidence);
+
+    // compute variance
+    let luma = rgb_to_luminance(result);
+    let variance = max(result_luma_moment2 - luma*luma, 0.0);
+
+    var output: SSRResolveOutput;
+    output.radiance = vec4f(color, variance);
+    output.metadata = ssr_resolve_metadata(distance_moments, max_confidence);
+    return output;
+}
+        `, [
+            chunk_ssr_metadata,
+            chunk_is_on_screen_i32,
+            chunk_decode_g_buffer_roughness,
+            chunk_direction_world_to_view,
+            chunk_screen_coordinate_to_view,
+            chunk_decode_g_buffer_normal,
+            chunk_rgb_to_YCoCg,
+            sample_radiance,
+            ...(sample_hit_irradiance === undefined ? [] : [sample_hit_irradiance]),
+            chunk_ssr_hit_unpack,
+            chunk_texel_coordinate_to_uv,
+            chunk_get_neighbour_weight,
+            chunk_is_background,
+            chunk_murmur3_vec3u,
+            chunk_reconstruct_pdf,
+            chunk_get_ray_mip_level,
+            chunk_project_position_from_depth,
+            chunk_v3_matrix4_project,
+            RECIPROCAL_PI_DECLARATION,
+            chunk_rgb_to_luminance,
+        ]
+    );
+
+    return new ImageShader({
+        descriptor: ShaderDescriptor.from({
+            label,
+            resources,
+            body
+        }),
+        targets: [
+            // TODO output rgbe5559 color and f16 variance to reduce memory bandwidth
+            {
+                format: "rgba16float"
+            },
+            { format: "rg32float" }
+        ],
+        depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    });
+}

package/src/shade/renderer/postprocess/ssr/resolve/chunk_get_neighbour_weight.js

@@ -43,7 +43,7 @@ fn get_neighbour_weight(
     // Range: Clamp at 2.0 for mirror-like, up to 10.0 for rough.
     let current_variance_limit = mix(2.0, 10.0, roughness);
         
-	return min(current_variance_limit, localBRDF / safe_pdf);;
+	return min(current_variance_limit, localBRDF / safe_pdf);
 }
     `, [
         SSR_RAY_HIT.declaration_chunk,

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_Brick4.d.ts

@@ -0,0 +1,2 @@
+export const ssr_resolve_shader_Brick4: import("../../../shader/ImageShader.js").ImageShader;
+//# sourceMappingURL=ssr_resolve_shader_Brick4.d.ts.map

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_Brick4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr_resolve_shader_Brick4.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_Brick4.js"],"names":[],"mappings":"AAWA,6FAYG"}

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_Brick4.js

@@ -0,0 +1,24 @@
+import { BRICK4_DATA_STRUCT } from "../../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { chunk_brick4_sample_specular } from "../../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_specular.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { build_ssr_resolve_shader } from "./build_ssr_resolve_shader.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer("brick4", BRICK4_DATA_STRUCT)
+    .addTexture("tSTBN_vec2", "unfilterable-float", "3d");
+
+export const ssr_resolve_shader_Brick4 = build_ssr_resolve_shader({
+    label: "SSR resolve / Brick4",
+    resources,
+    sample_radiance: CodeChunk.from(
+        //language=WGSL
+        `
+fn ssr_sample_radiance(
+    position_ws: vec3f, normal_ws: vec3f, view_direction_ws: vec3f, roughness: f32, coord: vec2u,
+) -> vec3f {
+    return brick4_sample_specular(position_ws, normal_ws, view_direction_ws, roughness, coord, settings.frame_index);
+}
+        `, [chunk_brick4_sample_specular]),
+});

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_IBL.d.ts

@@ -1,7 +1,2 @@
-/**
- * Maps traced SSR out to actual color
- * @type {ImageShader}
- */
-export const ssr_resolve_shader_IBL: ImageShader;
-import { ImageShader } from "../../../shader/ImageShader.js";
+export const ssr_resolve_shader_IBL: import("../../../shader/ImageShader.js").ImageShader;
 //# sourceMappingURL=ssr_resolve_shader_IBL.d.ts.map

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_IBL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_resolve_shader_IBL.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_IBL.js"],"names":[],"mappings":"AA+TA;;;GAGG;AACH,qCAFU,WAAW,CAelB;4BA9TyB,gCAAgC"}
+{"version":3,"file":"ssr_resolve_shader_IBL.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader_IBL.js"],"names":[],"mappings":"AAQA,0FAYG"}