@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.d.ts

@@ -7,6 +7,12 @@
  * @type {number[]}
  */
 export const VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION: number[];
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell this pass adds, each with
+ * its shadow tap. Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET: number;
 /**
  * The froxel irradiance volume (`chunk_volumetrics_irradiance_sh`): what a lit particle standing in a
  * froxel is lit by. Starts from the froxel GI stage's volume and adds every directional, point and

package/src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.js"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,0DAFU,MAAM,EAAE,CAEmD;AAwKrE;;;;;;;;;GASG;AACH,kDAFU,aAAa,CAMpB;8BA3M2B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.js"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,0DAFU,MAAM,EAAE,CAEmD;AAErE;;;;GAIG;AACH,kDAFU,MAAM,CAEsC;AA0KtD;;;;;;;;;GASG;AACH,kDAFU,aAAa,CAMpB;8BApN2B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.js

@@ -45,6 +45,13 @@ import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
  */
 export const VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION = [8, 8, 1];
 
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell this pass adds, each with
+ * its shadow tap. Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET = 32;
+
 const resources = new ShaderResourceSetDescriptor();
 
 // The froxel irradiance volume (chunk_volumetrics_irradiance_sh): luma SH2 in one, chroma in the .rg
@@ -151,7 +158,8 @@ fn main(
     let point_count = light_cluster_count_point(cluster_metadata.counts);
     let spot_count = light_cluster_count_spot(cluster_metadata.counts);
 
-    for (var j = 0u; j < point_count; j++) {
+    // Budget: VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET
+    for (var j = 0u; j < min(point_count, ${VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET}u); j++) {
         let light_index = cluster_data[cluster_offset + j];
         let direct_light = get_point_light_info_by_index(&light_data, light_index, position_ws);
 
@@ -164,7 +172,8 @@ fn main(
         irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
     }
 
-    for (var k = 0u; k < spot_count; k++) {
+    // Budget: VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET
+    for (var k = 0u; k < min(spot_count, ${VOLUMETRICS_IRRADIANCE_LIGHT_BUDGET}u); k++) {
         let light_index = cluster_data[cluster_offset + point_count + k];
         let direct_light = get_spot_light_info_by_index(&light_data, light_index, position_ws);
 

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.d.ts

@@ -15,6 +15,13 @@
  * @type {number[]}
  */
 export const VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION: number[];
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell the fog's in-scatter adds.
+ * Each one marches the medium toward the light and takes a shadow tap, the dearest per-light work here.
+ * Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_LIGHTING_LIGHT_BUDGET: number;
 export const shader_volumetrics_build_lighting: ComputeShader;
 import { ComputeShader } from "../shader/ComputeShader.js";
 //# sourceMappingURL=shader_volumetrics_build_lighting.d.ts.map

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;GAeG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAiXnE,8DAIE;8BA9Z4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;GAeG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAEnE;;;;;GAKG;AACH,gDAFU,MAAM,CAEoC;AAmXpD,8DAIE;8BAxa4B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js

@@ -36,7 +36,7 @@ import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_fro
 import { chunk_integrate_optical_depth } from "./chunk_integrate_optical_depth.js";
 import {
     chunk_volumetrics_sun_optical_depth,
-    volumetrics_sun_shadow_texture_name
+    VOLUMETRICS_SUN_SHADOW_CASCADE_RESOURCES
 } from "./chunk_volumetrics_sun_optical_depth.js";
 import { VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
 import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
@@ -61,6 +61,14 @@ import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
  */
 export const VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION = [8, 8, 1];
 
+/**
+ * The most point lights, and separately spot lights, of a froxel's cluster cell the fog's in-scatter adds.
+ * Each one marches the medium toward the light and takes a shadow tap, the dearest per-light work here.
+ * Chosen, not derived. Past it the rest of that type's list in the cell goes unshaded: the highest ids, except within one 32-light window where the GPU's lane order decides (PROPOSAL_HIERARCHICAL, I.6).
+ * @type {number}
+ */
+export const VOLUMETRICS_LIGHTING_LIGHT_BUDGET = 16;
+
 const resources = new ShaderResourceSetDescriptor();
 
 const primary_group = resources.createGroup()
@@ -78,7 +86,7 @@ const primary_group = resources.createGroup()
 // shader_volumetrics_build_sun_shadow_volume, one cascade per texture and innermost first.
 // Sampled, not marched.
 for (let cascade = 0; cascade < VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT; cascade++) {
-    primary_group.addTexture(volumetrics_sun_shadow_texture_name(cascade), "float", "3d");
+    primary_group.add(VOLUMETRICS_SUN_SHADOW_CASCADE_RESOURCES[cascade]);
 }
 
 primary_group.addStorageTexture("tLighting", "rgba16float", "3d", "write-only")
@@ -309,7 +317,8 @@ fn main(
         let point_count = light_cluster_count_point(cluster_metadata.counts);
         let spot_count = light_cluster_count_spot(cluster_metadata.counts);
 
-        for (var j = 0u; j < point_count; j++) {
+        // Budget: VOLUMETRICS_LIGHTING_LIGHT_BUDGET
+        for (var j = 0u; j < min(point_count, ${VOLUMETRICS_LIGHTING_LIGHT_BUDGET}u); j++) {
             let light_index = cluster_data[cluster_offset + j];
             var direct_light = get_point_light_info_by_index(&light_data, light_index, position_ws);
 
@@ -350,7 +359,8 @@ fn main(
             inScatteringSum += shadow_term * ms * direct_light.color;
         }
 
-        for (var k = 0u; k < spot_count; k++) {
+        // Budget: VOLUMETRICS_LIGHTING_LIGHT_BUDGET
+        for (var k = 0u; k < min(spot_count, ${VOLUMETRICS_LIGHTING_LIGHT_BUDGET}u); k++) {
             let light_index = cluster_data[cluster_offset + point_count + k];
             var direct_light = get_spot_light_info_by_index(&light_data, light_index, position_ws);
 

package/src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AAwOA,yEAIE;8BArN4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AAsPA,yEAIE;8BAnO4B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js

@@ -32,10 +32,13 @@ import { chunk_participating_media_volumes_iterate } from "./chunk_participating
 import { chunk_participating_media_noise } from "./noise/chunk_participating_media_noise.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "./noise/PARTICIPATING_MEDIA_NOISE.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_wind_field_sample } from "../wind/chunk_wind_field_sample.js";
+import { wind_field_add_resources } from "../wind/wind_field_add_resources.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
+// the scene's wind, which carries the noise: one uniform, one texture, one sampler
+wind_field_add_resources(resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
@@ -44,7 +47,7 @@ resources.createGroup()
     .addTexture("tParticipatingMediaNoise", "float", "3d")
     .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
     .addStorageTexture("tOutput0", "rgba16float", "3d", "write-only")
-    .addStorageTexture("tOutput1", "rgba16float", "3d", "write-only")
+    .addStorageTexture("tOutput1", "rgba16float", "3d", "write-only"));
 
 const body = CodeChunk.from(
     //language=WGSL
@@ -124,6 +127,11 @@ fn main(
     var scattering_luma_sum = 0.0;
     var anisotropic_g = 0.0;
 
+    // the wind at the noise point, sampled once a froxel by the first volume that feels it: every
+    // volume reads its noise at the same point
+    var noise_wind = wind_field.far_velocity;
+    var noise_wind_read = false;
+
     let volume_count = participating_media_volumes_count(&scene_database);
 
     for (var v = 0u; v < volume_count; v++) {
@@ -178,7 +186,12 @@ fn main(
         var noise = 1.0;
 
         if (volume.noise_strength > 0.0) {
-            noise = participating_media_noise_multiplier(volume, noise_position_ws);
+            if (volume.noise_wind_factor != 0.0 && !noise_wind_read) {
+                noise_wind = wind_field_sample(noise_position_ws);
+                noise_wind_read = true;
+            }
+
+            noise = participating_media_noise_multiplier_in_wind(volume, noise_position_ws, noise_wind);
         }
 
         let weight = volume.density * volume_coverage * edge_fade_factor * noise;
@@ -226,6 +239,7 @@ fn main(
         chunk_participating_media_volumes_iterate,
         chunk_frustum_sample_point,
         chunk_stbn_sample_vec3,
+        chunk_wind_field_sample,
         chunk_participating_media_noise,
     ]
 )

package/src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"volumetrics_position_world_to_froxel_uvw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,uDAFU,SAAS,CAoBlB;0BA3ByB,iCAAiC"}
+{"version":3,"file":"volumetrics_position_world_to_froxel_uvw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,uDAFU,SAAS,CAoBlB;0BA7ByB,iCAAiC"}

package/src/shade/renderer/volumetrics/volumetrics_position_world_to_froxel_uvw.js

@@ -1,6 +1,8 @@
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_froxel_content_offset.js";
 import { chunk_volumetrics_froxel_uvw_from_clip } from "./chunk_volumetrics_froxel_uvw_from_clip.js";
+import { CAMERA_RESOURCE } from "../camera/CAMERA_RESOURCE.js";
+import { VOLUMETRICS_METADATA_RESOURCE } from "./VOLUMETRICS_RESOURCES.js";
 
 /**
  * NOTE: we don't clamp final slice coordinate, this is intentional, we let the linear texture sampler take care of that.
@@ -26,3 +28,6 @@ fn volumetrics_position_world_to_froxel_uvw(
         chunk_volumetrics_froxel_uvw_from_clip,
     ]
 )
+
+volumetrics_position_world_to_froxel_uvw.requireResource(CAMERA_RESOURCE);
+volumetrics_position_world_to_froxel_uvw.requireResource(VOLUMETRICS_METADATA_RESOURCE);

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -42,7 +42,7 @@ export class GPUWaterRenderer {
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
     request_probe(uv: any): Promise<any>;
     dispose(): void;
-    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, indirect_lighting_mode, shader_switches }: {
+    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches }: {
         graph: any;
         view_ctx: any;
         camera: any;
@@ -55,7 +55,6 @@ export class GPUWaterRenderer {
         light_cluster_lookup: any;
         light_cluster_data: any;
         shadowmap_atlas: any;
-        indirect_lighting_mode?: number;
         shader_switches?: ShaderSwitchSet;
     }): {
         background_color: any;

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAuBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAuIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCAhY+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAmBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAmBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;MAoIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCAxX+B,uCAAuC"}

package/src/shade/renderer/water/GPUWaterRenderer.js

@@ -2,7 +2,6 @@ import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDes
 import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
 import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
 import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
-import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
 import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
 import { graph_water_tessellation } from "./surface/graph_water_tessellation.js";
 import { water_lod_view, WATER_LOD_VIEW_STRUCT } from "./surface/lod/WATER_LOD.js";
@@ -12,8 +11,7 @@ import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../geometry/meshlet/GEOMETRY_ME
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
-import { create_water_finalize_pipeline_brick4, create_water_finalize_pipeline_ibl, create_water_pipeline,
-    WATER_FINALIZE_RESOURCES_BRICK4, WATER_FINALIZE_RESOURCES_IBL, WATER_RESOURCES,
+import { create_water_finalize_pipeline, create_water_pipeline, WATER_FINALIZE_RESOURCES, WATER_RESOURCES,
     WATER_TRACE_STRUCT } from "./shader_water.js";
 import { WATER_BAND_SAMPLER } from "./surface/GPUWaterSurface.js";
 import { shader_water_background_copy, shader_water_debug, shader_water_draw,
@@ -36,21 +34,17 @@ export class GPUWaterRenderer {
      */
     bodies = null;
     #pipeline = create_water_pipeline();
-    /** The optics pipelines under IBL and under Brick4, each by the shader switch set it was built for. */
-    #finalize_pipelines_ibl = new Map();
-    #finalize_pipelines_brick4 = new Map();
+    /** The optics pipelines, each by the shader switch set it was built for. */
+    #finalize_pipelines = new Map();
     /**
-     * @param {boolean} use_brick4
      * @param {ShaderSwitchSet} shader_switches
      * @returns {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor}
      */
-    #finalize_pipeline(use_brick4, shader_switches) {
-        const cache = use_brick4 ? this.#finalize_pipelines_brick4 : this.#finalize_pipelines_ibl;
-        let pipeline = cache.get(shader_switches);
+    #finalize_pipeline(shader_switches) {
+        let pipeline = this.#finalize_pipelines.get(shader_switches);
         if (pipeline === undefined) {
-            pipeline = use_brick4 ? create_water_finalize_pipeline_brick4(shader_switches)
-                : create_water_finalize_pipeline_ibl(shader_switches);
-            cache.set(shader_switches, pipeline);
+            pipeline = create_water_finalize_pipeline(shader_switches);
+            this.#finalize_pipelines.set(shader_switches, pipeline);
         }
         return pipeline;
     }
@@ -163,7 +157,7 @@ export class GPUWaterRenderer {
 
     avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture,
         hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data,
-        shadowmap_atlas, indirect_lighting_mode = ShadeIndirectLightingMode.IBL, shader_switches = ShaderSwitchSet.EMPTY }) {
+        shadowmap_atlas, shader_switches = ShaderSwitchSet.EMPTY }) {
         const scene = view_ctx.scene;
         const settings = { ...this.settings };
         const probe = this.#probe;
@@ -240,11 +234,9 @@ export class GPUWaterRenderer {
             views.set(view_ctx, { data, mode: settings.debug_view, resolution });
         }
         const finalize_data = {};
-        // the optics read the GI mode the meshes in this frame are lit by: a reflection or a sky that
-        // misses on screen falls back to it, as SSR's resolve does
-        const use_brick4 = indirect_lighting_mode === ShadeIndirectLightingMode.Brick4;
-        const finalize_pipeline = this.#finalize_pipeline(use_brick4, shader_switches);
-        const finalize_resources = use_brick4 ? WATER_FINALIZE_RESOURCES_BRICK4 : WATER_FINALIZE_RESOURCES_IBL;
+        // the optics read the GI mode the meshes in this frame are lit by, through the switches: a
+        // reflection or a sky that misses on screen falls back to it, as SSR's resolve does
+        const finalize_pipeline = this.#finalize_pipeline(shader_switches);
         const finalize = graph.add('Water / coherent optics', finalize_data, (d, resources, {encoder, graphics}) => {
             const shared = {
                 camera: resources.get(d.camera), trace: encoder.allocateTransientValueBuffer(WATER_TRACE_STRUCT, settings),
@@ -261,12 +253,11 @@ export class GPUWaterRenderer {
                 cluster_data: resources.get(d.light_cluster_data),
                 shadowmapAtlas: resources.get(d.shadowmap_atlas).obtainView(),
                 sCompareLinear: graphics.samplers.obtain(SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR),
+                // the light map, read under Brick4
+                brick4: view_ctx.scene.volumetric_light_map.buffer,
+                view: view_ctx.uniform_buffer.buffer,
             };
-            if (use_brick4) {
-                shared.brick4 = view_ctx.scene.volumetric_light_map.buffer;
-                shared.view = view_ctx.uniform_buffer.buffer;
-            }
-            const bindings = finalize_resources.generateBindings(shared, encoder);
+            const bindings = WATER_FINALIZE_RESOURCES.generateBindings(shared, encoder);
             const copy_pipeline = shader_water_background_copy.pipeline;
             const copy_bindings = shader_water_background_copy.descriptor.resources.generateBindings({tScene: shared.tScene}, encoder);
             const render = encoder.constructRenderPass({label: 'Water / coherent optics', pipeline: finalize_pipeline, bindings: [],

package/src/shade/renderer/water/chunk_water_gi.d.ts

@@ -1,14 +1,22 @@
 /**
  * The environment map: irradiance as its roughness-1 level × π, specular from its prefiltered levels.
- * Expects `tEnvironment`.
+ * Reads `tEnvironment`.
  * @type {CodeChunk}
  */
 export const chunk_water_gi_ibl: CodeChunk;
 /**
  * Brick4, the volumetric directional light map: position-dependent, so water under a bridge receives
- * less sky and reflects the bridge's light rather than the sky. Expects `brick4` and `view`.
+ * less sky and reflects the bridge's light rather than the sky. Reads `brick4` and `view`.
  * @type {CodeChunk}
  */
 export const chunk_water_gi_brick4: CodeChunk;
+/**
+ * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL and LPV
+ * {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}. A pipeline that links it binds
+ * `tEnvironment`, `brick4` and `view`, and reads only its own mode's.
+ * @type {CodeChunkChoice}
+ */
+export const chunk_water_gi: CodeChunkChoice;
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
 //# sourceMappingURL=chunk_water_gi.d.ts.map

package/src/shade/renderer/water/chunk_water_gi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;0BAlDjB,iCAAiC"}
+{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;GAKG;AACH,6BAFU,eAAe,CAE6C;0BA1D5C,iCAAiC;gCAC3B,uCAAuC"}

package/src/shade/renderer/water/chunk_water_gi.js

@@ -1,56 +1,70 @@
-import { chunk_get_ibl_irradiance } from "../deferred/indirect/chunk_get_ibl_irradiance.js";
-import { chunk_get_ibl_radiance } from "../deferred/indirect/chunk_get_ibl_radiance.js";
-import {
-    chunk_brick4_sample_forward_indirect
-} from "../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-
-/*
- What the engine's indirect lighting says at a point on the water, one module per indirect-lighting
- mode, as SSR's resolve and the transparent mesh draw are split (WATER_OPTICS_PLAN_2026_10_02.md
- §5.4). Each defines the same two functions, so the water's optics body is written once and composed
- with either:
-
- - water_gi_irradiance(position, normal): plane irradiance on a surface facing normal — the sky light
-   that enters the water;
- - water_gi_specular(position, normal, view_direction, roughness): the radiance a reflection that
-   missed on screen falls back to. view_direction points from the surface to the camera.
-
- LPV has no transparent variant: like the transparent meshes, water uses the IBL module under it.
-*/
-
-/**
- * The environment map: irradiance as its roughness-1 level × π, specular from its prefiltered levels.
- * Expects `tEnvironment`.
- * @type {CodeChunk}
- */
-export const chunk_water_gi_ibl = CodeChunk.from(/* language=WGSL */ `
-fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
-    return get_ibl_irradiance(normal);
-}
-
-fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> vec3<f32> {
-    return get_ibl_radiance(view_direction, normal, roughness);
-}
-`, [chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
-
-/**
- * Brick4, the volumetric directional light map: position-dependent, so water under a bridge receives
- * less sky and reflects the bridge's light rather than the sky. Expects `brick4` and `view`.
- * @type {CodeChunk}
- */
-export const chunk_water_gi_brick4 = CodeChunk.from(/* language=WGSL */ `
-fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
-    var radiance: vec3<f32>;
-    var irradiance: vec3<f32>;
-    brick4_sample_forward_indirect(position, normal, normal, normal, 1.0, &radiance, &irradiance);
-    return irradiance;
-}
-
-fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> vec3<f32> {
-    var radiance: vec3<f32>;
-    var irradiance: vec3<f32>;
-    brick4_sample_forward_indirect(position, view_direction, normal, normal, roughness, &radiance, &irradiance);
-    return radiance;
-}
-`, [chunk_brick4_sample_forward_indirect]);
+import { chunk_get_ibl_irradiance } from "../deferred/indirect/chunk_get_ibl_irradiance.js";
+import { chunk_get_ibl_radiance } from "../deferred/indirect/chunk_get_ibl_radiance.js";
+import {
+    chunk_brick4_sample_forward_indirect
+} from "../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
+import { INDIRECT_LIGHTING } from "../INDIRECT_LIGHTING.js";
+import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+
+/*
+ What the engine's indirect lighting says at a point on the water, by the renderer's indirect
+ lighting mode, as SSR's resolve and the transparent mesh draw choose theirs (WATER_OPTICS_PLAN_2026_10_02.md
+ §5.4). Each alternative defines the same two functions, so the water's optics body is written once:
+
+ - water_gi_irradiance(position, normal): plane irradiance on a surface facing normal — the sky light
+   that enters the water;
+ - water_gi_specular(position, normal, view_direction, roughness): the radiance a reflection that
+   missed on screen falls back to. view_direction points from the surface to the camera.
+
+ LPV has no transparent sampling: like the transparent meshes, water uses the environment under it.
+*/
+
+/**
+ * The environment map: irradiance as its roughness-1 level × π, specular from its prefiltered levels.
+ * Reads `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_water_gi_ibl = CodeChunk.from(/* language=WGSL */ `
+fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
+    return get_ibl_irradiance(normal);
+}
+
+fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> vec3<f32> {
+    return get_ibl_radiance(view_direction, normal, roughness);
+}
+`, [chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
+
+/**
+ * Brick4, the volumetric directional light map: position-dependent, so water under a bridge receives
+ * less sky and reflects the bridge's light rather than the sky. Reads `brick4` and `view`.
+ * @type {CodeChunk}
+ */
+export const chunk_water_gi_brick4 = CodeChunk.from(/* language=WGSL */ `
+fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
+    var radiance: vec3<f32>;
+    var irradiance: vec3<f32>;
+    brick4_sample_forward_indirect(position, normal, normal, normal, 1.0, &radiance, &irradiance);
+    return irradiance;
+}
+
+fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> vec3<f32> {
+    var radiance: vec3<f32>;
+    var irradiance: vec3<f32>;
+    brick4_sample_forward_indirect(position, view_direction, normal, normal, roughness, &radiance, &irradiance);
+    return radiance;
+}
+`, [chunk_brick4_sample_forward_indirect]);
+
+/**
+ * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL and LPV
+ * {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}. A pipeline that links it binds
+ * `tEnvironment`, `brick4` and `view`, and reads only its own mode's.
+ * @type {CodeChunkChoice}
+ */
+export const chunk_water_gi = CodeChunkChoice.from(INDIRECT_LIGHTING);
+
+chunk_water_gi.add(ShadeIndirectLightingMode.IBL, chunk_water_gi_ibl);
+chunk_water_gi.add(ShadeIndirectLightingMode.Brick4, chunk_water_gi_brick4);
+chunk_water_gi.add(ShadeIndirectLightingMode.LPV, chunk_water_gi_ibl);

package/src/shade/renderer/water/optics/chunk_water_inscatter.d.ts

@@ -18,8 +18,8 @@
  * The medium's phase functions enter through b_b, which the bodies table integrates from them on the
  * GPU. The model is gated against the Monte Carlo slab oracle (`water_inscatter_oracle.spec.js`).
  *
- * Expects `light_data` and the shadow atlas bindings, and a `water_gi_irradiance` from one of the GI
- * modules. Returns radiance arriving at the surface from below; the caller takes it out of the water.
+ * Expects a `water_gi_irradiance` from one of the GI modules. Returns radiance arriving at the surface from below;
+ * the caller takes it out of the water.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/water/optics/chunk_water_inscatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_inscatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_inscatter.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,oCAFU,SAAS,CAwFmF;0BApH5E,oCAAoC"}
+{"version":3,"file":"chunk_water_inscatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_inscatter.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,oCAFU,SAAS,CAwFmF;0BArH5E,oCAAoC"}

package/src/shade/renderer/water/optics/chunk_water_inscatter.js

@@ -9,6 +9,7 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_shadowmap_get_light_visibility } from "../../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
 import { WATER_BODY_STRUCT } from "../medium/WATER_BODIES_STRUCT.js";
 import { chunk_water_optics } from "./chunk_water_optics.js";
+import { LIGHT_DATA_RESOURCE } from "../../light/LIGHT_DATA_RESOURCE.js";
 
 /**
  * Light the water body sends back towards a viewer above it (WATER_OPTICS_PLAN_2026_10_02.md §4.4):
@@ -30,8 +31,8 @@ import { chunk_water_optics } from "./chunk_water_optics.js";
  * The medium's phase functions enter through b_b, which the bodies table integrates from them on the
  * GPU. The model is gated against the Monte Carlo slab oracle (`water_inscatter_oracle.spec.js`).
  *
- * Expects `light_data` and the shadow atlas bindings, and a `water_gi_irradiance` from one of the GI
- * modules. Returns radiance arriving at the surface from below; the caller takes it out of the water.
+ * Expects a `water_gi_irradiance` from one of the GI modules. Returns radiance arriving at the surface from below;
+ * the caller takes it out of the water.
  *
  * @type {CodeChunk}
  */
@@ -122,3 +123,5 @@ fn water_inscatter(body: WaterBody, origin: vec3<f32>, direction: vec3<f32>, up:
 }
 `, [WATER_BODY_STRUCT.declaration_chunk, chunk_water_optics, chunk_directional_lights_iteration_mask,
     chunk_get_directional_light_info_by_index, chunk_shadowmap_get_light_visibility, PI_DECLARATION]);
+
+chunk_water_inscatter.requireResource(LIGHT_DATA_RESOURCE);

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.d.ts

@@ -18,8 +18,7 @@
  * Stated limits: light the receiver had from lamps and its own emission is scaled by the same ratio,
  * and a highlight keeps its dry direction, scaled.
  *
- * Expects `light_data` and the shadow atlas bindings, and a `water_gi_irradiance` from one of the GI
- * modules.
+ * Expects a `water_gi_irradiance` from one of the GI modules.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_receiver_downwelling.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+CAFU,SAAS,CAyCmE;0BArE5D,oCAAoC"}
+{"version":3,"file":"chunk_water_receiver_downwelling.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAFU,SAAS,CAyCmE;0BArE5D,oCAAoC"}

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js

@@ -8,6 +8,7 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_shadowmap_get_light_visibility } from "../../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
 import { WATER_BODY_STRUCT } from "../medium/WATER_BODIES_STRUCT.js";
 import { chunk_water_optics } from "./chunk_water_optics.js";
+import { LIGHT_DATA_RESOURCE } from "../../light/LIGHT_DATA_RESOURCE.js";
 
 /**
  * Light reaching a submerged receiver (WATER_OPTICS_PLAN_2026_10_02.md §4.3), applied by the water
@@ -29,8 +30,7 @@ import { chunk_water_optics } from "./chunk_water_optics.js";
  * Stated limits: light the receiver had from lamps and its own emission is scaled by the same ratio,
  * and a highlight keeps its dry direction, scaled.
  *
- * Expects `light_data` and the shadow atlas bindings, and a `water_gi_irradiance` from one of the GI
- * modules.
+ * Expects a `water_gi_irradiance` from one of the GI modules.
  *
  * @type {CodeChunk}
  */
@@ -74,3 +74,5 @@ fn water_receiver_downwelling(body: WaterBody, receiver: vec3<f32>, normal: vec3
 }
 `, [WATER_BODY_STRUCT.declaration_chunk, chunk_water_optics, chunk_directional_lights_iteration_mask,
     chunk_get_directional_light_info_by_index, chunk_shadowmap_get_light_visibility]);
+
+chunk_water_receiver_downwelling.requireResource(LIGHT_DATA_RESOURCE);

package/src/shade/renderer/water/shader_water.d.ts

@@ -1,19 +1,16 @@
 export function create_water_pipeline(): RenderPipelineDescriptor;
-/** The optics pipeline under IBL, its shader built for `switches` (a ShaderSwitchSet). */
-export function create_water_finalize_pipeline_ibl(switches: any): RenderPipelineDescriptor;
-/** The optics pipeline under Brick4, its shader built for `switches` (a ShaderSwitchSet). */
-export function create_water_finalize_pipeline_brick4(switches: any): RenderPipelineDescriptor;
+/** The optics pipeline, its shader built for `switches` (a ShaderSwitchSet). */
+export function create_water_finalize_pipeline(switches: any): RenderPipelineDescriptor;
 export const WATER_TRACE_STRUCT: WebGPUStruct;
-/** Optics under IBL (and LPV, which has no transparent variant): the lights and the environment. */
-export const WATER_FINALIZE_RESOURCES_IBL: ShaderResourceSetDescriptor;
-/** Optics under Brick4: the lights, and the light map with the view its sampling jitters by. */
-export const WATER_FINALIZE_RESOURCES_BRICK4: ShaderResourceSetDescriptor;
+/**
+ * The optics: the lights, the environment, and the light map with the view its sampling jitters by.
+ * Every indirect lighting mode's resources, whichever the pipeline's variant reads (`chunk_water_gi`).
+ */
+export const WATER_FINALIZE_RESOURCES: ShaderResourceSetDescriptor;
 export const chunk_water_screen_ray: CodeChunk;
 export const water_shader: ShaderDescriptor;
-/** The optics pass under IBL, and under LPV, which has no transparent variant. */
-export const water_finalize_shader_ibl: ShaderDescriptor;
-/** The optics pass under Brick4. */
-export const water_finalize_shader_brick4: ShaderDescriptor;
+/** The optics pass; its variants differ in the indirect lighting they fall back to, and bind alike. */
+export const water_finalize_shader: ShaderDescriptor;
 export const WATER_RESOURCES: ShaderResourceSetDescriptor;
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";

package/src/shade/renderer/water/shader_water.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AA+mBA,kEAAuH;AACvH,0FAA0F;AAC1F,4FAEC;AACD,6FAA6F;AAC7F,+FAEC;AA7kBD,8CAKwB;AAiCxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAqOrE,+CAsFmB;AA8LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCAnlBA,8DAA8D;6BAkB1E,gCAAgC;4CAJjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAyoBA,kEAAuH;AACvH,gFAAgF;AAChF,wFAEC;AAzlBD,8CAKwB;AAwCxB;;;GAGG;AACH,mEAA8D;AA4O9D,+CAsFmB;AAoMnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCA7mBA,8DAA8D;6BAwB1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}