@woosh/meep-engine 3.47.0 → 3.50.0

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

@@ -1,49 +1,33 @@
-import { chunk_ndc_to_uv } from "../shader/chunk/texture/chunk_ndc_to_uv.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_froxel_content_offset.js";
-
-/**
- * NOTE: we don't clamp final slice coordinate, this is intentional, we let the linear texture sampler take care of that.
- * See {@link build_light_cluster_parameters}
- * @type {CodeChunk}
- */
-export const volumetrics_position_world_to_froxel_uvw = CodeChunk.from(
-    //language=WGSL
-    `
-fn volumetrics_position_world_to_froxel_uvw(
-    position_ws: vec3<f32>
-) -> vec3<f32>{
-
-    let position_vs = camera.view_matrix * vec4(position_ws, 1.0);
-    let position_clip = camera.projection_matrix * position_vs;
-    
-    let uv = ndc_to_uv(position_clip.xy / position_clip.w);
- 
-    let view_depth = -position_vs.z;
-
-    // froxel_cluster_parameters, NOT cluster_parameters: this addresses the FROXEL grid, which the
-    // participating-media pass builds on that curve. cluster_parameters is the aerial LUT's. The
-    // two are identical while froxel_far is unset — which is why the mix-up went unnoticed — and
-    // diverge as soon as the grid is packed into a shorter range.
-    let cluster_parameters = volumetrics_metadata.froxel_cluster_parameters;
-
-    // see 'cluster_depth_to_z_slice' for explanation
-    let slice_position:f32 = log2(fma(view_depth, cluster_parameters.x, cluster_parameters.y)) * cluster_parameters.z;
-
-    // A cell-averaged grid: texel k holds the slab [k+j, k+1+j], not the point at slice k, so the
-    // texel-centre convention alone reads about half a froxel too far out. See
-    // chunk_volumetrics_froxel_content_offset for where the ~0.53 comes from.
-    let content_offset = volumetrics_froxel_content_offset(cluster_parameters.z);
-
-    let w = (slice_position + 0.5 - content_offset) / f32(volumetrics_metadata.resolution.z);
-    
-    return vec3(
-        uv,
-        w
-    );
-}
-    `, [
-        chunk_ndc_to_uv,
-        chunk_volumetrics_froxel_content_offset,
-    ]
-)
+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.
+ * See {@link build_light_cluster_parameters}
+ * @type {CodeChunk}
+ */
+export const volumetrics_position_world_to_froxel_uvw = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_position_world_to_froxel_uvw(
+    position_ws: vec3<f32>
+) -> vec3<f32>{
+
+    let position_vs = camera.view_matrix * vec4(position_ws, 1.0);
+    let position_clip = camera.projection_matrix * position_vs;
+
+    let content_offset = volumetrics_froxel_content_offset(volumetrics_metadata.froxel_cluster_parameters.z);
+
+    return volumetrics_froxel_uvw_from_clip(position_clip, -position_vs.z, content_offset);
+}
+    `, [
+        chunk_volumetrics_froxel_content_offset,
+        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 }: {
+    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,7 @@ export class GPUWaterRenderer {
         light_cluster_lookup: any;
         light_cluster_data: any;
         shadowmap_atlas: any;
-        indirect_lighting_mode?: number;
+        shader_switches?: ShaderSwitchSet;
     }): {
         background_color: any;
     };
@@ -95,4 +95,5 @@ export class GPUWaterRenderer {
     inspect(graph: any, view_ctx: any, output_resolution: any): number;
     #private;
 }
+import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
 //# sourceMappingURL=GPUWaterRenderer.d.ts.map

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;IAOd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;MAgJC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}
+{"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,7 @@ 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";
 import { WATER_LOD_LIMITS_STRUCT, WATER_LOD_PATCH_INDICES, WATER_LOD_STATISTICS_WORDS,
@@ -11,13 +11,11 @@ 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,
-    shader_water_occupancy, shader_water_splat, shader_water_confidence_seed,
-    shader_water_confidence_x, shader_water_confidence_y } from "./shader_water_avboit.js";
+    shader_water_occupancy, shader_water_splat } from "./shader_water_avboit.js";
 
 /** Production water channel. Only AVBOIT's shared resolve composites its radiance. */
 export class GPUWaterRenderer {
@@ -36,8 +34,20 @@ export class GPUWaterRenderer {
      */
     bodies = null;
     #pipeline = create_water_pipeline();
-    #finalize_pipeline_ibl = create_water_finalize_pipeline_ibl();
-    #finalize_pipeline_brick4 = create_water_finalize_pipeline_brick4();
+    /** The optics pipelines, each by the shader switch set it was built for. */
+    #finalize_pipelines = new Map();
+    /**
+     * @param {ShaderSwitchSet} shader_switches
+     * @returns {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor}
+     */
+    #finalize_pipeline(shader_switches) {
+        let pipeline = this.#finalize_pipelines.get(shader_switches);
+        if (pipeline === undefined) {
+            pipeline = create_water_finalize_pipeline(shader_switches);
+            this.#finalize_pipelines.set(shader_switches, pipeline);
+        }
+        return pipeline;
+    }
     #prepared = new WeakMap();
     #inspection = new WeakMap();
     #probe = null;
@@ -147,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 }) {
+        shadowmap_atlas, shader_switches = ShaderSwitchSet.EMPTY }) {
         const scene = view_ctx.scene;
         const settings = { ...this.settings };
         const probe = this.#probe;
@@ -223,20 +233,10 @@ export class GPUWaterRenderer {
             if (views === undefined) { views = new Map(); this.#inspection.set(graph, views); }
             views.set(view_ctx, { data, mode: settings.debug_view, resolution });
         }
-        const visibility_resolution = resolution.map(v => Math.ceil(v / 4));
-        const [seeds] = graph_image_pass({ graph, shader: shader_water_confidence_seed,
-            inputs: { trace_metadata: data.trace_metadata, scene_depth: data.scene_depth }, output_resolution: visibility_resolution });
-        const [horizontal] = graph_image_pass({ graph, shader: shader_water_confidence_x,
-            inputs: { distance_field: seeds }, output_resolution: visibility_resolution });
-        const [visibility_distance] = graph_image_pass({ graph, shader: shader_water_confidence_y,
-            inputs: { distance_field: horizontal }, output_resolution: visibility_resolution });
-        data.visibility_distance = visibility_distance;
         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 = use_brick4 ? this.#finalize_pipeline_brick4 : this.#finalize_pipeline_ibl;
-        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),
@@ -244,7 +244,6 @@ export class GPUWaterRenderer {
                 tNormal: resources.get(d.normal).obtainView(), tHZB: resources.get(d.hzb).obtainView(),
                 tScene: resources.get(d.color).obtainView(),
                 receiver: resources.get(d.receiver).obtainView(), trace_metadata: resources.get(d.trace_metadata).obtainView(),
-                visibility_distance: resources.get(d.visibility_distance).obtainView(),
                 ...geometry_bindings(graphics, encoder, resources, d),
                 // the lights, as the transparent meshes bind them
                 light_data: view_ctx.scene.lights.buffer_data,
@@ -254,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: [],
@@ -274,7 +272,7 @@ export class GPUWaterRenderer {
             draw(render, resources.get(d.commands), graphics.device);
             render.end();
         });
-        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','visibility_distance','interface_depth',
+        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','interface_depth',
             'lod_bodies','candidates','cells','commands']) {
             finalize_data[key] = finalize.read(data[key]);
         }
@@ -370,10 +368,9 @@ export class GPUWaterRenderer {
                     const mapped = buffer.getMappedRange();
                     const half = offset => Array.from(new Float16Array(mapped, offset, 4));
                     const radiance = half(512);
-                    const confidence = radiance[3];
                     radiance[3] = new Float32Array(mapped, 768, 4)[1];
                     probe.resolve({ pixel, resolution, frame_time: optical.frame_time, receiver: Array.from(new Float32Array(mapped, 0, 4)),
-                        transmission: Array.from(new Float32Array(mapped, 256, 4)), radiance, confidence, stale: false });
+                        transmission: Array.from(new Float32Array(mapped, 256, 4)), radiance, stale: false });
                 } catch (error) { probe.reject(error); }
                 finally { buffer.destroy(); }
             });

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/chunk_water_transport.d.ts

@@ -1,5 +1,4 @@
 export const WATER_LEVEL_TOLERANCE_DECLARATION: CodeChunk;
-export const chunk_water_refraction_confidence: CodeChunk;
 export const chunk_water_transport: CodeChunk;
 export const chunk_water_receiver_texel: CodeChunk;
 export const chunk_water_receiver_radiance: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAUA,0DAEG;AAEH,0DAeG;AAEH,8CAsBG;AAIH,mDAU6F;AAI7F,sDAmCoE;0BA1G1C,iCAAiC"}
+{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAUA,0DAEG;AAEH,8CAsBG;AAIH,mDAU6F;AAI7F,sDAmCoE;0BAzF1C,iCAAiC"}

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

@@ -12,23 +12,6 @@ export const WATER_LEVEL_TOLERANCE_DECLARATION = CodeChunk.from(/* language=WGSL
 const WATER_LEVEL_TOLERANCE: f32 = 0.02;
 `);
 
-export const chunk_water_refraction_confidence = CodeChunk.from(/* language=WGSL */ `
-fn water_refraction_lookup(original: vec2f, receiver: vec2f, confidence: f32) -> vec2f {
-    return mix(original, receiver, clamp(confidence, 0.0, 1.0));
-}
-fn water_refraction_confidence(uv: vec2f, original_uv: vec2f, size: vec2f, distance_tiles: f32) -> f32 {
-    let displacement = length((uv - original_uv) * size);
-    let fade_width = clamp(displacement, 8.0, 64.0);
-    let visibility = smoothstep(0.0, fade_width, distance_tiles * 4.0);
-    // Distance from the frame border of whichever of source and receiver is nearer to it.
-    let edge = min(min(original_uv, 1.0 - original_uv), min(uv, 1.0 - uv));
-    // Approaching an off-screen receiver must approach the control lookup continuously,
-    // even while the water fragment itself is far enough from the frame border.
-    return visibility * smoothstep(0.0, clamp(displacement / min(size.x, size.y), 0.01, 0.1),
-        min(edge.x, edge.y));
-}
-`);
-
 export const chunk_water_transport = CodeChunk.from(/* language=WGSL */ `
 struct WaterEvent { transmission: vec3f, radiance: vec3f }
 struct WaterTransport { transmission: vec3f, radiance: vec3f, background: vec3f }

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,17 +1,16 @@
 export function create_water_pipeline(): RenderPipelineDescriptor;
-export function create_water_finalize_pipeline_ibl(): RenderPipelineDescriptor;
-export function create_water_finalize_pipeline_brick4(): 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":"AA0mBA,kEAAuH;AACvH,+EAA+J;AAC/J,kFAAqK;AAjkBrK,8CAKwB;AAiCxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAqOrE,+CA+EmB;AA+LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCA9kBA,8DAA8D;6BAmB1E,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"}