@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.js

@@ -1,68 +1,71 @@
-import { assert } from "../../../../core/assert.js";
-import { atomic_u32, f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    PARTICLE_VM_WIDE_LAUNCH_LANES,
-    PARTICLE_WARMUP_LAUNCH_LANES,
-    PARTICLE_WARMUP_WORKGROUP_SIZE,
-} from "../ParticleConstants.js";
-import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.js";
-import { chunk_particle_warmup_step } from "./chunk_particle_warmup_step.js";
-import { WARMUP_ADVANCE_BODY, WARMUP_ADVANCE_SETTINGS } from "./shader_particle_warmup_advance.js";
-
-/**
- * The warm-up's advance pass over the WIDE register file — for a system whose hungriest effect has
- * put the interpreter on the storage-backed file. Same pass as
- * {@link ./shader_particle_warmup_advance.js}, same entry point text, plus the register bind and the
- * ninth binding, exactly as the main simulate's wide variant relates to its fast one.
- *
- * The register file is indexed by launch lane and reused across the grid-stride loop's iterations,
- * which is sound for the reason `../vm/chunk_particle_vm_registers_wide.js` gives: a program writes
- * a register before it reads it. It is the same buffer the main wide passes use, sized by
- * {@link PARTICLE_VM_WIDE_LAUNCH_LANES}, which is why the warm-up's launch must be exactly that wide.
- *
- * @type {ComputeShader}
- */
-
-assert.equal(
-    PARTICLE_WARMUP_LAUNCH_LANES, PARTICLE_VM_WIDE_LAUNCH_LANES,
-    "the warm-up's launch must match the wide register file's lane count, which sizes the file",
-);
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", WARMUP_ADVANCE_SETTINGS);
-
-resources.createGroup()
-    .addStorageBuffer("scene_database", WebGPUArray.u32, false)
-    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
-    .addStorageBuffer("program", WebGPUArray.u32, false)
-    .addStorageBuffer("pool", WebGPUArray.u32, true)
-    .addStorageBuffer("alive_in", WebGPUArray.u32, false)
-    .addStorageBuffer("alive_out", WebGPUArray.u32, true)
-    .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("vm_registers", WebGPUArray.from(f32), true);
-
-export const shader_particle_warmup_advance_wide = ComputeShader.from({
-    label: "Particle Warm-up Advance (wide registers)",
-    resources,
-    body: CodeChunk.from(/* language=wgsl */ `
-${WARMUP_ADVANCE_BODY}
-
-@compute @workgroup_size(${PARTICLE_WARMUP_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    // This invocation's column of the register file. The launch is exactly
-    // PARTICLE_WARMUP_LAUNCH_LANES wide, so gid.x is in range by construction.
-    particle_vm_bind_registers(gid.x);
-
-    particle_warmup_advance_all(gid.x);
-}
-`, [
-        chunk_particle_warmup_step,
-        chunk_particle_vm_registers_wide,
-    ]),
-});
+import { assert } from "../../../../core/assert.js";
+import { atomic_u32, f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    PARTICLE_VM_WIDE_LAUNCH_LANES,
+    PARTICLE_WARMUP_LAUNCH_LANES,
+    PARTICLE_WARMUP_WORKGROUP_SIZE,
+} from "../ParticleConstants.js";
+import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.js";
+import { chunk_particle_vm_wind_field } from "../vm/chunk_particle_vm_wind_field.js";
+import { wind_field_add_resources } from "../../wind/wind_field_add_resources.js";
+import { chunk_particle_warmup_step } from "./chunk_particle_warmup_step.js";
+import { WARMUP_ADVANCE_BODY, WARMUP_ADVANCE_SETTINGS } from "./shader_particle_warmup_advance.js";
+
+/**
+ * The warm-up's advance pass over the WIDE register file — for a system whose hungriest effect has
+ * put the interpreter on the storage-backed file. Same pass as
+ * {@link ./shader_particle_warmup_advance.js}, same entry point text, plus the register bind and the
+ * ninth binding, exactly as the main simulate's wide variant relates to its fast one.
+ *
+ * The register file is indexed by launch lane and reused across the grid-stride loop's iterations,
+ * which is sound for the reason `../vm/chunk_particle_vm_registers_wide.js` gives: a program writes
+ * a register before it reads it. It is the same buffer the main wide passes use, sized by
+ * {@link PARTICLE_VM_WIDE_LAUNCH_LANES}, which is why the warm-up's launch must be exactly that wide.
+ *
+ * @type {ComputeShader}
+ */
+
+assert.equal(
+    PARTICLE_WARMUP_LAUNCH_LANES, PARTICLE_VM_WIDE_LAUNCH_LANES,
+    "the warm-up's launch must match the wide register file's lane count, which sizes the file",
+);
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", WARMUP_ADVANCE_SETTINGS);
+
+wind_field_add_resources(resources.createGroup()
+    .addStorageBuffer("scene_database", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
+    .addStorageBuffer("program", WebGPUArray.u32, false)
+    .addStorageBuffer("pool", WebGPUArray.u32, true)
+    .addStorageBuffer("alive_in", WebGPUArray.u32, false)
+    .addStorageBuffer("alive_out", WebGPUArray.u32, true)
+    .addStorageBuffer("dead", WebGPUArray.u32, true)
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("vm_registers", WebGPUArray.from(f32), true));
+
+export const shader_particle_warmup_advance_wide = ComputeShader.from({
+    label: "Particle Warm-up Advance (wide registers)",
+    resources,
+    body: CodeChunk.from(/* language=wgsl */ `
+${WARMUP_ADVANCE_BODY}
+
+@compute @workgroup_size(${PARTICLE_WARMUP_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    // This invocation's column of the register file. The launch is exactly
+    // PARTICLE_WARMUP_LAUNCH_LANES wide, so gid.x is in range by construction.
+    particle_vm_bind_registers(gid.x);
+
+    particle_warmup_advance_all(gid.x);
+}
+`, [
+        chunk_particle_warmup_step,
+        chunk_particle_vm_registers_wide,
+        chunk_particle_vm_wind_field,
+    ]),
+});

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;GAcG;AACH;IAoFI;;;OAGG;IACH,sBAFW,eAAe,EAmBzB;IAvGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IAsOtB;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;;;OAOG;IACH;QAJmC,IAAI,EAA5B,cAAc;QACM,KAAK,EAAzB,UAAU;QACR,MAAM,CA4JlB;;CACJ;yBAldY,OAAO,8DAA8D,EAAE,UAAU;8BAIjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc"}
+{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;GAcG;AACH;IA8EI;;;OAGG;IACH,sBAFW,eAAe,EAkBzB;IAhGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA+NtB;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;;;OAOG;IACH;QAJmC,IAAI,EAA5B,cAAc;QACM,KAAK,EAAzB,UAAU;QACR,MAAM,CA8JlB;;CACJ;yBA7cY,OAAO,8DAA8D,EAAE,UAAU;8BAIjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc"}

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js

@@ -99,12 +99,6 @@ export class AccumulatingPathTracer {
     /** @type {GPUDevice} */
     #device;
 
-    /**
-     * For the sampler cache: the volumes' noise atlas is sampled through a shared sampler.
-     * @type {GraphicsContext}
-     */
-    #graphics;
-
     /**
      * Cached zero-filled CPU buffer used to clear ping-pong textures via
      * `queue.writeTexture`. Lazily grown to fit the current resolution.
@@ -127,7 +121,6 @@ export class AccumulatingPathTracer {
         assert.defined(graphics, 'graphics');
 
         this.#device = graphics.device;
-        this.#graphics = graphics;
 
         for (let i = 0; i < 2; i++) {
             const t = new GPUTextureContext(graphics.device);
@@ -433,7 +426,9 @@ export class AccumulatingPathTracer {
                     light_data: scene_ctx.lights.buffer_data,
                     tEnvironment: view.scene.lights.environment.obtainView(),
                     tParticipatingMediaNoise: view.scene.volumetrics.noise_atlas.texture.obtainView(),
-                    sParticipatingMediaNoise: this.#graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
+                    sParticipatingMediaNoise: graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
+                    wind_field: scene_ctx.wind.uniform,
+                    wind_field_atlas: scene_ctx.wind.atlas.texture,
 
                     settings,
                     camera: view.camera.gpu_buffer,

package/src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_accumulating_path_tracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js"],"names":[],"mappings":"AAmBA,2DAKG;AAkFH,4DAIG;6BA5G0B,mCAAmC;8BAOlC,+BAA+B"}
+{"version":3,"file":"shader_accumulating_path_tracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js"],"names":[],"mappings":"AAoBA,2DAKG;AAmFH,4DAIG;6BA9G0B,mCAAmC;8BAOlC,+BAA+B"}

package/src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js

@@ -14,6 +14,7 @@ import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../material/resident/INDIRECT_M
 import { MEDIA_TABLE_STRUCT } from "../../medium/MEDIA_TABLE_STRUCT.js";
 import { chunk_render_trace_path } from "../shader/chunk_render_trace_path.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
+import { wind_field_add_resources } from "../../wind/wind_field_add_resources.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -35,12 +36,13 @@ resources.createGroup()
     .addUniform("media", MEDIA_TABLE_STRUCT)
     .addTexture("textures", "unfilterable-float", "2d-array");
 
-resources.createGroup()
+// the scene's wind, which carries the fog volumes' noise: one uniform, one texture, one sampler
+wind_field_add_resources(resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
     .addTexture("tEnvironment", "unfilterable-float", "2d")
     // the fog volumes' noise, read through participating_media_volume_density_at
     .addTexture("tParticipatingMediaNoise", "float", "3d")
-    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR);
+    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR));
 
 resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)

package/src/shade/renderer/path_tracer/graph_path_trace_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_path_trace_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/path_tracer/graph_path_trace_scene.js"],"names":[],"mappings":"AAsGA;;;;;;GAMG;AACH;IAJ+B,KAAK;IACD,IAAI;IAC1B,MAAM,CAuFlB"}
+{"version":3,"file":"graph_path_trace_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/path_tracer/graph_path_trace_scene.js"],"names":[],"mappings":"AAwGA;;;;;;GAMG;AACH;IAJ+B,KAAK;IACD,IAAI;IAC1B,MAAM,CAyFlB"}

package/src/shade/renderer/path_tracer/graph_path_trace_scene.js

@@ -17,6 +17,7 @@ import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../material/resident/INDIRECT_MATE
 import { MEDIA_TABLE_STRUCT } from "../medium/MEDIA_TABLE_STRUCT.js";
 import { chunk_render_trace_path } from "./shader/chunk_render_trace_path.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
+import { wind_field_add_resources } from "../wind/wind_field_add_resources.js";
 
 const RAY_TRACING_UNIFORMS_STRUCT = WebGPUStruct.from({
     random_seed: u32
@@ -31,12 +32,13 @@ resources.createGroup()
     .addUniform("media", MEDIA_TABLE_STRUCT)
     .addTexture("textures", "unfilterable-float", "2d-array")
 
-resources.createGroup()
+// the scene's wind, which carries the fog volumes' noise: one uniform, one texture, one sampler
+wind_field_add_resources(resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
     .addTexture("tEnvironment", "unfilterable-float", "2d")
     // the fog volumes' noise, read through participating_media_volume_density_at
     .addTexture("tParticipatingMediaNoise", "float", "3d")
-    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
+    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR));
 
 resources.createGroup()
     .addUniform("common_uniforms", RAY_TRACING_UNIFORMS_STRUCT)
@@ -172,6 +174,8 @@ export function graph_path_trace_scene({
                 tEnvironment: view.scene.lights.environment.obtainView(),
                 tParticipatingMediaNoise: scene_ctx.volumetrics.noise_atlas.texture.obtainView(),
                 sParticipatingMediaNoise: graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
+                wind_field: scene_ctx.wind.uniform,
+                wind_field_atlas: scene_ctx.wind.atlas.texture,
 
                 common_uniforms: rt_uniforms,
                 camera: view.camera.gpu_buffer,

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js

@@ -5,7 +5,7 @@ import { chunk_scene_database_access } from "../../scene/chunk_scene_database_ac
 import { chunk_BRDF_GGX } from "../../shader/chunk/brdf/chunk_BRDF_GGX.js";
 import { chunk_compute_ggx_vndf_pdf } from "../../shader/chunk/brdf/chunk_compute_ggx_pdf.js";
 import { chunk_oren_nayar_compensated_diffuse } from "../../shader/chunk/brdf/diffuse/EON.js";
-import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_F_Schlick } from "../../shader/chunk/brdf/fresnel/chunk_F_Schlick.js";
 import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_sample_reflection_vector } from "../../shader/chunk/screen_space/chunk_sample_reflection_vector.js";
 import {
@@ -511,7 +511,7 @@ fn render_trace_path(
             }
         }
                 
-        let fresnel = F_Hauber(shading_material.specularF0, shading_material.specularF90, NoV);
+        let fresnel = F_Schlick(shading_material.specularF0, shading_material.specularF90, NoV);
         let specular_weight = rgb_to_luminance(fresnel);
         let diffuse_weight = rgb_to_luminance(shading_material.diffuse);
 
@@ -541,7 +541,7 @@ fn render_trace_path(
             let VoH = saturate(dot(V, H));
 
             // Fresnel evaluated for this specific bounce
-            let F = F_Hauber(shading_material.specularF0, shading_material.specularF90, VoH);
+            let F = F_Schlick(shading_material.specularF0, shading_material.specularF90, VoH);
 
             // This is the "Magic" cancellation for VNDF + Smith Correlated
             let a2 = alpha * alpha;
@@ -655,7 +655,7 @@ fn render_trace_path(
         chunk_get_cosine_weighted_sample,
         chunk_compute_ggx_vndf_pdf,
         chunk_russian_roulette,
-        chunk_F_Hauber,
+        chunk_F_Schlick,
         chunk_shadow_terminator_term_Dreamworks2020,
         chunk_scene_database_access,
         chunk_participating_media_volumes_iterate,

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -2,7 +2,7 @@ import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry
 import {
     chunk_mat4_linear_determinant
 } from "../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
-import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_F_Schlick } from "../../shader/chunk/brdf/fresnel/chunk_F_Schlick.js";
 import { chunk_albedo_unpremultiply } from "../../shader/chunk/material/chunk_albedo_unpremultiply.js";
 import {
     chunk_build_orthonormal_matrix_nt
@@ -90,7 +90,7 @@ fn sample_material_alpha(
         let f_metalness = material.metallic_factor; // ORM texture not sampled in alpha path; metallic_factor is enough for typical glass (metalness = 0)
         let specular_f0 = dielectric_specular_color(material.ior_factor, f_metalness, albedo);
         let nov = saturate(abs(dot(world_face_normal, ray_direction)));
-        let f_view = F_Hauber(specular_f0, 1.0, nov);
+        let f_view = F_Schlick(specular_f0, 1.0, nov);
         let f_scalar = max(f_view.r, max(f_view.g, f_view.b));
         // Glass coverage tracks the view-Fresnel reflection coefficient.
         // No per-channel transmission tint in the material today — when one
@@ -127,7 +127,7 @@ fn sample_material_alpha(
         chunk_interpolate_attribute_2f32,
         chunk_dielectric_specular_color,
         chunk_albedo_unpremultiply,
-        chunk_F_Hauber,
+        chunk_F_Schlick,
     ]
 )
 

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#197@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#200@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

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

@@ -44,19 +44,22 @@ 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
      * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number, denoise_tiles:number}}
      */
-    graph_pass({ graph, input_depth, input_depth_previous, view_ctx, jitter, input_hzb, input_scene_color, input_pbr, input_normal, input_velocity, input_occlusion, input_albedo, resolution, camera_current, camera_previous, input_environment, indirect_lighting_mode, lpv, brick4, mip, }: {
+    graph_pass({ graph, input_depth, input_depth_previous, view_ctx, jitter, input_hzb, input_scene_color, input_pbr, input_normal, input_velocity, input_occlusion, input_albedo, resolution, camera_current, camera_previous, input_environment, shader_switches, lpv, brick4, mip, }: {
         graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
         input_depth: number;
         input_depth_previous?: number;
@@ -67,11 +70,11 @@ export class SSR {
         input_normal: number;
         input_velocity: number;
         input_occlusion: number;
-        input_environment?: number;
+        input_environment: number;
         resolution: ArrayLike<number>;
         camera_current: number;
         camera_previous: number;
-        indirect_lighting_mode?: ShadeIndirectLightingMode;
+        shader_switches?: ShaderSwitchSet;
         brick4?: import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
         lpv?: import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
         view_ctx?: import("../../view/GPUViewContext.js").GPUViewContext;
@@ -87,5 +90,5 @@ export class SSR {
     };
     #private;
 }
-import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
+import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";
 //# sourceMappingURL=SSR.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAmBA;IAwEI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA1ED,oBAAgB;IAWhB,2CAMC;IAZD;;;;OAIG;IACH,sCAAqE;IAoCrE,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAxBnD,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IAY3E,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,aAAa,EAAC,MAAM,CAAA;KAAC,CA+QtH;;CACJ;0CAvayC,oCAAoC"}
+{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IA6EI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA1ED,oBAAgB;IAWhB,2CAMC;IAZD;;;;OAIG;IACH,sCAAqE;IAoCrE,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAxBnD,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IAY3E,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAzBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QAEuE,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QAEkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAElB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,aAAa,EAAC,MAAM,CAAA;KAAC,CAsQtH;;CACJ;gCApa+B,0CAA0C"}

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/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"}