@woosh/meep-engine 3.47.0 → 3.50.0

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

@@ -1,13 +1,11 @@
-import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
-import { ssr_resolve_shader_Brick4 } from "./resolve/ssr_resolve_shader_Brick4.js";
+import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";
+import { ssr_resolve_shader } from "./resolve/ssr_resolve_shader.js";
 import { SSRReprojectionMode } from "./SSRReprojectionMode.js";
 import { assert } from "../../../../core/assert.js";
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
-import { ssr_resolve_shader_IBL } from "./resolve/ssr_resolve_shader_IBL.js";
-import { ssr_resolve_shader_LPV } from "./resolve/ssr_resolve_shader_LPV.js";
 import { ssr_combine_shader } from "./ssr_combine_shader.js";
 import { ssr_graph_prefilter_color } from "./ssr_graph_prefilter_color.js";
 import { SSR_PREFILTER_MIP_COUNT } from "./SSR_PREFILTER_MIP_COUNT.js";
@@ -29,7 +27,12 @@ export class SSR {
     #read_index = 0;
     #last_frame = -1;
     #last_view;
-    #last_indirect_lighting_mode;
+    /**
+     * The resolve the history was made with: a variant per indirect lighting mode, so a new mode starts
+     * the history again.
+     * @type {import("../../shader/ImageShader.js").ImageShader|undefined}
+     */
+    #last_resolve_shader;
     #last_jitter = [0, 0];
     #valid = false;
     #generation = 0;
@@ -139,13 +142,16 @@ export class SSR {
      * @param {number} options.input_normal
      * @param {number} options.input_velocity
      * @param {number} options.input_occlusion
-     * @param {number} [options.input_environment]
+     * @param {number} options.input_environment the environment map
      * @param {ArrayLike<number>} options.resolution
      * @param {number} options.camera_current
      * @param {number} options.camera_previous
-     * @param {ShadeIndirectLightingMode} [options.indirect_lighting_mode] Explicit GI fallback selection
-     * @param {import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4]
-     * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv]
+     * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the resolve is built for them, and
+     *   falls back to the indirect lighting they say where the trace finds nothing
+     * @param {import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
+     *   while Brick4 runs
+     * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
+     *   scene's, while LPV runs. A source not given is the resolve's default, for a variant that does not read it
      * @param {import("../../view/GPUViewContext.js").GPUViewContext} [options.view_ctx]
      * @param {ArrayLike<number>} [options.jitter] Raster jitter in internal pixels
      * @param {number} [options.mip] Higher mip = lower resolution trace
@@ -167,43 +173,17 @@ export class SSR {
                    resolution,
                    camera_current,
                    camera_previous,
-                   input_environment = -1,
-                   indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
+                   input_environment,
+                   shader_switches = ShaderSwitchSet.EMPTY,
                    lpv,
                    brick4,
                    mip = 0,
                }) {
 
         assert.defined(camera_current, 'camera');
+        assert.isNonNegativeInteger(input_environment, 'input_environment');
 
-        let resolve_shader;
-        let gi_inputs;
-        switch (indirect_lighting_mode) {
-            case ShadeIndirectLightingMode.IBL:
-                resolve_shader = ssr_resolve_shader_IBL;
-                gi_inputs = { tEnvironment: input_environment };
-                break;
-            case ShadeIndirectLightingMode.Brick4:
-                assert.defined(brick4, 'SSR Brick4 lightmap');
-                resolve_shader = ssr_resolve_shader_Brick4;
-                gi_inputs = { brick4: brick4.buffer, tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2 };
-                break;
-            case ShadeIndirectLightingMode.LPV:
-                assert.defined(lpv, 'SSR LPV');
-                resolve_shader = ssr_resolve_shader_LPV;
-                gi_inputs = {
-                    tEnvironment: input_environment,
-                    lpv_atlas_radiance: lpv.atlas.texture_radiance,
-                    lpv_atlas_depth: lpv.atlas.texture_depth,
-                    lpv_lookup: lpv.buffer_mesh_bvh,
-                    lpv_metadata: lpv.buffer_metadata,
-                    lpv_mesh: lpv.buffer_mesh,
-                    lpv_probes: lpv.buffer_probes,
-                };
-                break;
-            default:
-                throw new Error(`Unsupported SSR indirect lighting mode: ${indirect_lighting_mode}`);
-        }
+        const resolve_shader = ssr_resolve_shader.variant(shader_switches);
 
         this.resize(resolution[0], resolution[1]);
 
@@ -212,7 +192,7 @@ export class SSR {
 
         const valid = this.#valid && !this.#reset_history && input_depth_previous >= 0
             && this.#last_frame === frame_index - 1 && this.#last_view === view_ctx
-            && this.#last_indirect_lighting_mode === indirect_lighting_mode;
+            && this.#last_resolve_shader === resolve_shader;
         const read_index = this.#read_index;
         const write_index = 1 - read_index;
         const generation = ++this.#generation;
@@ -236,7 +216,7 @@ export class SSR {
                 this.#read_index = write_index;
                 this.#last_frame = frame_index;
                 this.#last_view = view_ctx;
-                this.#last_indirect_lighting_mode = indirect_lighting_mode;
+                this.#last_resolve_shader = resolve_shader;
                 this.#last_jitter = current_jitter;
                 this.#reset_history = false;
                 this.#valid = true;
@@ -281,22 +261,39 @@ export class SSR {
             mip_count: SSR_PREFILTER_MIP_COUNT
         });
 
+        const resolve_inputs = {
+            tEnvironment: input_environment,
+            tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+            settings: { frame_index },
+            tTrace: trace,
+            tColor: scene_color_filtered,
+            tDepth: input_depth,
+            tPBR: input_pbr,
+            tAlbedoAO: input_albedo,
+            tNormal: input_normal,
+            camera: camera_current,
+        };
+
+        // the running mode's source; the others are the resolve's defaults, which its variant does not read
+        if (brick4 !== undefined) {
+            resolve_inputs.brick4 = brick4.buffer;
+        }
+
+        if (lpv !== undefined) {
+            resolve_inputs.lpv_lookup = lpv.buffer_mesh_bvh;
+            resolve_inputs.lpv_metadata = lpv.buffer_metadata;
+            resolve_inputs.lpv_mesh = lpv.buffer_mesh;
+            resolve_inputs.lpv_probes = lpv.buffer_probes;
+            resolve_inputs.lpv_atlas_radiance = lpv.atlas.texture_radiance;
+            resolve_inputs.lpv_atlas_depth = lpv.atlas.texture_depth;
+        }
+
         const [reflections, reflection_metadata] = graph_image_pass({
             graph,
             shader: resolve_shader,
             output_resolution: resolution,
             input_depth,
-            inputs: {
-                ...gi_inputs,
-                settings: { frame_index },
-                tTrace: trace,
-                tColor: scene_color_filtered,
-                tDepth: input_depth,
-                tPBR: input_pbr,
-                tAlbedoAO: input_albedo,
-                tNormal: input_normal,
-                camera: camera_current,
-            },
+            inputs: resolve_inputs,
         });
 
         const tile_denoising = this.#tile_denoising_enabled

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,sDA0IuH;0BArJ7F,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,sDA6IuH;0BAxJ7F,uCAAuC"}

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

@@ -92,6 +92,9 @@ fn ssr_temporal_accumulate(current: vec4f, previous: vec4f, previous_age: f32,
                 // 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; }
+                // These two unprojections are ~14% of SSR Reproject (2026-10-16, RTX 4090: evaluating them twice
+                // cost 1.14-1.17x). The three.js-style alternative, each camera's unprojection set up once per
+                // pixel so a tap is three multiply-adds, made the pass 1.12-1.17x slower, not faster.
                 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));

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

@@ -0,0 +1,28 @@
+/**
+ * {@link chunk_ssr_add_hit_irradiance} for a mode that adds nothing: the call is empty.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_none: CodeChunk;
+/**
+ * {@link chunk_ssr_add_hit_irradiance} from the light probe volume: the diffuse light the volume says
+ * the hit surface receives, reflected by its albedo. Reads the LPV's buffers and atlas, `tAlbedoAO`
+ * and `camera`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_lpv: CodeChunk;
+/**
+ * The indirect light SSR's resolve adds to an on-screen hit, by the renderer's indirect lighting mode
+ * ({@link INDIRECT_LIGHTING}): one diffuse bounce from the light probe volume under LPV, nothing under
+ * the others.
+ *
+ * ```wgsl
+ * fn ssr_add_hit_irradiance(result: ptr<function, vec3f>, confidence, position_ws, hit_position_vs,
+ *     hit_normal_ws, hit_coord: vec2u)
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_ssr_add_hit_irradiance: CodeChunkChoice;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_ssr_add_hit_irradiance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_add_hit_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,gDAFU,SAAS,CAcR;AAEX;;;;;GAKG;AACH,+CAFU,SAAS,CAyBZ;AAKP;;;;;;;;;;;GAWG;AACH,2CAFU,eAAe,CAE2D;0BArE1D,uCAAuC;gCACjC,6CAA6C"}

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

@@ -0,0 +1,79 @@
+import { INDIRECT_LIGHTING } from "../../../INDIRECT_LIGHTING.js";
+import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
+import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
+import { chunk_lpv_sample_irradiance } from "../../../shader/chunk/light/lpv/chunk_lpv_sample_irradiance.js";
+import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+import { CAMERA_RESOURCE } from "../../../camera/CAMERA_RESOURCE.js";
+import { GBUFFER_ALBEDO_AO_RESOURCE } from "../../../deferred/GBUFFER_RESOURCES.js";
+
+/**
+ * {@link chunk_ssr_add_hit_irradiance} for a mode that adds nothing: the call is empty.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_none = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_add_hit_irradiance(
+    result: ptr<function, vec3f>,
+    confidence: f32,
+    position_ws: vec3f,
+    hit_position_vs: vec3f,
+    hit_normal_ws: vec3f,
+    hit_coord: vec2u,
+) {
+}
+    `, []);
+
+/**
+ * {@link chunk_ssr_add_hit_irradiance} from the light probe volume: the diffuse light the volume says
+ * the hit surface receives, reflected by its albedo. Reads the LPV's buffers and atlas, `tAlbedoAO`
+ * and `camera`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_lpv = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_add_hit_irradiance(
+    result: ptr<function, vec3f>,
+    confidence: f32,
+    position_ws: vec3f,
+    hit_position_vs: vec3f,
+    hit_normal_ws: vec3f,
+    hit_coord: vec2u,
+) {
+    if (confidence > 0.05) {
+        let hit_position_ws = v3_matrix4_project(hit_position_vs, camera.view_matrix_inverse);
+        let hit_direction_ws = normalize(hit_position_ws - position_ws);
+        let hit_irradiance = lpv_sample_irradiance(hit_position_ws, hit_normal_ws, hit_direction_ws);
+        let hit_albedo = textureLoad(tAlbedoAO, hit_coord, 0).rgb;
+        *result += hit_albedo * hit_irradiance * RECIPROCAL_PI;
+    }
+}
+    `, [
+        chunk_lpv_sample_irradiance,
+        chunk_v3_matrix4_project,
+        RECIPROCAL_PI_DECLARATION,
+    ]);
+
+chunk_ssr_add_hit_irradiance_lpv.requireResource(CAMERA_RESOURCE);
+chunk_ssr_add_hit_irradiance_lpv.requireResource(GBUFFER_ALBEDO_AO_RESOURCE);
+
+/**
+ * The indirect light SSR's resolve adds to an on-screen hit, by the renderer's indirect lighting mode
+ * ({@link INDIRECT_LIGHTING}): one diffuse bounce from the light probe volume under LPV, nothing under
+ * the others.
+ *
+ * ```wgsl
+ * fn ssr_add_hit_irradiance(result: ptr<function, vec3f>, confidence, position_ws, hit_position_vs,
+ *     hit_normal_ws, hit_coord: vec2u)
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_ssr_add_hit_irradiance = CodeChunkChoice.from(INDIRECT_LIGHTING);
+
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_add_hit_irradiance_none);
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_add_hit_irradiance_none);
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_add_hit_irradiance_lpv);

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

@@ -0,0 +1,30 @@
+/**
+ * {@link chunk_ssr_sample_radiance} from the environment map. Reads `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_ibl: CodeChunk;
+/**
+ * {@link chunk_ssr_sample_radiance} from Brick4's probes, jittered per pixel and frame. Reads `brick4`,
+ * `tSTBN_vec2` and the resolve's `settings.frame_index`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_brick4: CodeChunk;
+/**
+ * {@link chunk_ssr_sample_radiance} from the light probe volume. Reads the LPV's buffers and its atlas.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_lpv: CodeChunk;
+/**
+ * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
+ * lighting mode ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_ssr_sample_radiance: CodeChunkChoice;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_ssr_sample_radiance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,4CAFU,SAAS,CAUc;AAEjC;;;;GAIG;AACH,+CAFU,SAAS,CAUoB;AAEvC;;;GAGG;AACH,4CAFU,SAAS,CAUiB;AAEpC;;;;;;;;;GASG;AACH,wCAFU,eAAe,CAEwD;0BAxDvD,uCAAuC;gCACjC,6CAA6C"}

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

@@ -0,0 +1,66 @@
+import { chunk_get_ibl_radiance } from "../../../deferred/indirect/chunk_get_ibl_radiance.js";
+import { chunk_brick4_sample_specular } from "../../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_specular.js";
+import { INDIRECT_LIGHTING } from "../../../INDIRECT_LIGHTING.js";
+import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
+import { chunk_lpv_sample_radiance } from "../../../shader/chunk/light/lpv/chunk_lpv_sample_radiance.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+
+/**
+ * {@link chunk_ssr_sample_radiance} from the environment map. Reads `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_ibl = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_sample_radiance(
+    position_ws: vec3f, normal_ws: vec3f, view_direction_ws: vec3f, roughness: f32, coord: vec2u,
+) -> vec3f {
+    return get_ibl_radiance(view_direction_ws, normal_ws, roughness);
+}
+    `, [chunk_get_ibl_radiance]);
+
+/**
+ * {@link chunk_ssr_sample_radiance} from Brick4's probes, jittered per pixel and frame. Reads `brick4`,
+ * `tSTBN_vec2` and the resolve's `settings.frame_index`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_brick4 = 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]);
+
+/**
+ * {@link chunk_ssr_sample_radiance} from the light probe volume. Reads the LPV's buffers and its atlas.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_lpv = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_sample_radiance(
+    position_ws: vec3f, normal_ws: vec3f, view_direction_ws: vec3f, roughness: f32, coord: vec2u,
+) -> vec3f {
+    return lpv_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness);
+}
+    `, [chunk_lpv_sample_radiance]);
+
+/**
+ * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
+ * lighting mode ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_ssr_sample_radiance = CodeChunkChoice.from(INDIRECT_LIGHTING);
+
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_sample_radiance_ibl);
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_sample_radiance_brick4);
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_sample_radiance_lpv);

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

@@ -0,0 +1,11 @@
+/**
+ * SSR's hit resolve: the traced hits of each pixel and its neighbours, weighed by the BRDF, over what
+ * the renderer's indirect lighting says where they found nothing. One shader for every indirect lighting
+ * mode, by a shader switch ({@link chunk_ssr_sample_radiance}, {@link chunk_ssr_add_hit_irradiance}),
+ * binding every mode's resources by name.
+ *
+ * @type {ImageShader}
+ */
+export const ssr_resolve_shader: ImageShader;
+import { ImageShader } from "../../../shader/ImageShader.js";
+//# sourceMappingURL=ssr_resolve_shader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AA+VA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BAlWyB,gCAAgC"}

package/src/shade/renderer/postprocess/ssr/resolve/{build_ssr_resolve_shader.js → ssr_resolve_shader.js}

@@ -6,7 +6,7 @@ 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_project_view_position_from_depth } from "../../../shader/chunk/camera/chunk_project_view_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";
@@ -24,46 +24,54 @@ import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_backgr
 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";
+import { BRICK4_DATA_STRUCT } from "../../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS } from "../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { BLACK_PIXEL_TEXTURE } from "../../../texture/util/BLACK_PIXEL_TEXTURE.js";
+import { ZERO_UINT_PIXEL_TEXTURE } from "../../../texture/util/ZERO_UINT_PIXEL_TEXTURE.js";
+import { chunk_ssr_add_hit_irradiance } from "./chunk_ssr_add_hit_irradiance.js";
+import { chunk_ssr_sample_radiance } from "./chunk_ssr_sample_radiance.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
-        `
+const resources = new ShaderResourceSetDescriptor();
+
+// What every indirect lighting mode samples where the trace found nothing, whichever the variant
+// reads (chunk_ssr_sample_radiance, chunk_ssr_add_hit_irradiance): the environment, Brick4's probes and
+// the noise that jitters them, and the light probe volume. The pass binds only the running mode's, and each
+// mode's source has a default for the others: black textures, transient buffers, a volume of no probes.
+resources.createGroup()
+    .addTexture("tEnvironment")
+    .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
+    .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
+    .addTexture("lpv_atlas_radiance", "uint", "2d", false, ZERO_UINT_PIXEL_TEXTURE)
+    .addTexture("lpv_atlas_depth", "float", "2d", false, BLACK_PIXEL_TEXTURE);
+// the light probe volume
+resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
+
+// 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),
@@ -177,6 +185,9 @@ fn main(
     // 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;
 
+    // Every position in here is view space, reconstructed from four entries of the projection's inverse rather
+    // than a full multiply. Measured 2026-10-16 (RTX 4090, ssr_reprojection playground, roughness 0.2): the full
+    // multiply took 1.03-1.04x this pass's time at 960x600 and 1.03-1.05x at 1280x800, with bit-identical output.
     const NEIGHBOUR_SAMPLE_COUNT = 4;
 
     let hash_seed = murmur3_vec3u(vec3u(vec2u(coord_i), settings.frame_index));
@@ -201,7 +212,7 @@ fn main(
         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(
+        let sample_hit_position_vs = project_view_position_from_depth(
             sample_hit_uv,
             sample_hit_depth,
             camera.projection_matrix_inverse,
@@ -292,17 +303,10 @@ fn main(
     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;
-    }
-    `}
+    // one bounce of indirect light at the hit, under a mode that has it
+    ssr_add_hit_irradiance(
+        &result, this_confidence, this_position_ws, this_hit_position_vs, this_hit_normal_ws, this_hit.position,
+    );
 
     let gi_radiance = ssr_sample_radiance(
         this_position_ws, this_normal_ws, view_direction_ws, this_roughness, vec2u(coord_i),
@@ -321,43 +325,50 @@ fn main(
     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,
-        ]
-    );
+    `, [
+        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,
+        chunk_ssr_sample_radiance,
+        chunk_ssr_add_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_view_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,
-    });
-}
+/**
+ * SSR's hit resolve: the traced hits of each pixel and its neighbours, weighed by the BRDF, over what
+ * the renderer's indirect lighting says where they found nothing. One shader for every indirect lighting
+ * mode, by a shader switch ({@link chunk_ssr_sample_radiance}, {@link chunk_ssr_add_hit_irradiance}),
+ * binding every mode's resources by name.
+ *
+ * @type {ImageShader}
+ */
+export const ssr_resolve_shader = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "SSR resolve",
+        resources,
+        body
+    }),
+    targets: [
+        // TODO output rgbe5559 color and f16 variance to reduce memory bandwidth
+        {
+            format: "rgba16float"
+        },
+        { format: "rg32float" }
+    ],
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+});