@woosh/meep-engine 3.49.0 → 3.51.0

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

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

@@ -1,7 +1,7 @@
 import { GPUShaderStage } from "../../descriptor/GPUShaderStage.js";
 import { DepthStencilState } from "../../descriptor/pipeline/render/DepthStencilState.js";
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CAMERA_RESOURCE } from "../camera/CAMERA_RESOURCE.js";
 import { SHADING_LIGHT_RESOURCE_GROUP } from "../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
 import { BRICK4_DATA_STRUCT } from "../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
 import { chunk_F_dielectric } from "../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
@@ -14,18 +14,28 @@ import { chunk_ffx_sssr_validate_hit } from "../shader/chunk/screen_space/chunk_
 import { chunk_project_direction } from "../shader/chunk/screen_space/chunk_project_direction.js";
 import { chunk_screen_space_newton_ray } from "../shader/chunk/screen_space/chunk_screen_space_newton_ray.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import {
+    SCREEN_DEPTH_RESOURCE,
+    SCREEN_HZB_RESOURCE,
+    SCREEN_NORMAL_RESOURCE
+} from "../shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js";
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
-import { chunk_water_gi_brick4, chunk_water_gi_ibl } from "./chunk_water_gi.js";
+import { chunk_water_gi } from "./chunk_water_gi.js";
 import { WATER_BODIES_TABLE, WATER_WAVES_TABLE } from "./medium/chunk_water_bodies.js";
-import { MESHLET_METADATA_STRUCT } from "../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import { COLLECTION_U32_STRUCT_READ } from "../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { GEOMETRY_ATTRIBUTE_DATA_RESOURCE } from "../geometry/GEOMETRY_ATTRIBUTE_DATA_RESOURCE.js";
+import { MESHLET_METADATA_RESOURCE } from "../geometry/meshlet/MESHLET_METADATA_RESOURCE.js";
+import { SCENE_DATABASE_RESOURCE } from "../scene/SCENE_DATABASE_RESOURCE.js";
 import { chunk_water_surface_sample } from "./surface/chunk_water_surface_sample.js";
-import { WATER_PARTICLE_ENTRY_STRUCT } from "./surface/particles/WATER_PARTICLE_STRUCT.js";
+import {
+    WATER_BAND_DERIVATIVES_RESOURCE, WATER_BAND_DISPLACEMENT_RESOURCE, WATER_BAND_SAMPLER_RESOURCE,
+    WATER_PARTICLE_ENTRIES_RESOURCE, WATER_PARTICLE_OFFSETS_RESOURCE
+} from "./surface/WATER_SURFACE_RESOURCES.js";
 import { WATER_LOD_BODY_STRUCT, WATER_LOD_VIEW_STRUCT, WaterLodMode } from "./surface/lod/WATER_LOD.js";
 import { chunk_water_lod_candidate, chunk_water_lod_layout, WATER_LOD_BOUNDARY_FIRST_VERTEX, WATER_LOD_CANDIDATE_STRUCT,
     WATER_LOD_CELL_LOCAL_BITS, WATER_LOD_LIMITS_STRUCT, WATER_LOD_PATCH_FIRST_VERTEX, WATER_LOD_PATCH_SIDE, WATER_LOD_POLYGON_WORDS,
@@ -47,30 +57,37 @@ export const WATER_TRACE_STRUCT = WebGPUStruct.from({
     inscatter_segments: u32,
 }, "WaterTrace").pack();
 
+const TRACE_RESOURCE = ShaderResourceDescriptor.uniform("trace", WATER_TRACE_STRUCT);
+// the view's lattice (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3)
+const LOD_RESOURCE = ShaderResourceDescriptor.uniform('lod', WATER_LOD_VIEW_STRUCT);
+const LOD_LIMITS_RESOURCE = ShaderResourceDescriptor.uniform('lod_limits', WATER_LOD_LIMITS_STRUCT);
+const LOD_BODIES_RESOURCE = ShaderResourceDescriptor.storageBuffer('water_lod_bodies', WebGPUArray.from(WATER_LOD_BODY_STRUCT));
+const LOD_CANDIDATES_RESOURCE = ShaderResourceDescriptor.storageBuffer('water_lod_candidates', WebGPUArray.from(WATER_LOD_CANDIDATE_STRUCT));
+const LOD_CELLS_RESOURCE = ShaderResourceDescriptor.storageBuffer('water_lod_cells', WebGPUArray.u32);
+
 function water_resources(finalize = false) {
     const resources = new ShaderResourceSetDescriptor();
     const group = resources.createGroup()
-        .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-        .addUniform("trace", WATER_TRACE_STRUCT)
-        .addTexture("tDepth")
-        .addTexture("tNormal", "uint")
-        .addTexture("tHZB")
+        .add(CAMERA_RESOURCE)
+        .add(TRACE_RESOURCE)
+        .add(SCREEN_DEPTH_RESOURCE)
+        .add(SCREEN_NORMAL_RESOURCE)
+        .add(SCREEN_HZB_RESOURCE)
         .addTexture("tScene")
-        .addStorageBuffer('scene_database', WebGPUArray.u32)
-        // the view's lattice (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3)
-        .addUniform('lod', WATER_LOD_VIEW_STRUCT)
-        .addUniform('lod_limits', WATER_LOD_LIMITS_STRUCT)
-        .addStorageBuffer('water_lod_bodies', WebGPUArray.from(WATER_LOD_BODY_STRUCT))
-        .addStorageBuffer('water_lod_candidates', WebGPUArray.from(WATER_LOD_CANDIDATE_STRUCT))
-        .addStorageBuffer('water_lod_cells', WebGPUArray.u32)
-        .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT))
-        .addStorageBuffer('meshlet_data', WebGPUArray.from(f32))
+        .add(SCENE_DATABASE_RESOURCE)
+        .add(LOD_RESOURCE)
+        .add(LOD_LIMITS_RESOURCE)
+        .add(LOD_BODIES_RESOURCE)
+        .add(LOD_CANDIDATES_RESOURCE)
+        .add(LOD_CELLS_RESOURCE)
+        .add(MESHLET_METADATA_RESOURCE)
+        .add(GEOMETRY_ATTRIBUTE_DATA_RESOURCE)
         // the surface interface: the spectral bands and the frame's binned wave particles
-        .addTexture('water_band_displacement', 'float', '2d-array')
-        .addTexture('water_band_derivatives', 'float', '2d-array')
-        .addSampler('water_band_sampler')
-        .addStorageBuffer('water_particle_offsets', COLLECTION_U32_STRUCT_READ)
-        .addStorageBuffer('water_particle_entries', WebGPUArray.from(WATER_PARTICLE_ENTRY_STRUCT));
+        .add(WATER_BAND_DISPLACEMENT_RESOURCE)
+        .add(WATER_BAND_DERIVATIVES_RESOURCE)
+        .add(WATER_BAND_SAMPLER_RESOURCE)
+        .add(WATER_PARTICLE_OFFSETS_RESOURCE)
+        .add(WATER_PARTICLE_ENTRIES_RESOURCE);
     if (finalize) {
         group.addTexture('receiver').addTexture('trace_metadata');
     }
@@ -78,14 +95,13 @@ function water_resources(finalize = false) {
 }
 const resources = water_resources();
 
-/** Optics under IBL (and LPV, which has no transparent variant): the lights and the environment. */
-export const WATER_FINALIZE_RESOURCES_IBL = water_resources(true);
-WATER_FINALIZE_RESOURCES_IBL.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
-
-/** Optics under Brick4: the lights, and the light map with the view its sampling jitters by. */
-export const WATER_FINALIZE_RESOURCES_BRICK4 = water_resources(true);
-WATER_FINALIZE_RESOURCES_BRICK4.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
-WATER_FINALIZE_RESOURCES_BRICK4.createGroup()
+/**
+ * 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 = water_resources(true);
+WATER_FINALIZE_RESOURCES.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
+WATER_FINALIZE_RESOURCES.createGroup()
     .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false)
     .addUniform("view", VIEW_UNIFORM_STRUCT);
 
@@ -312,6 +328,13 @@ fn water_interface(world: vec3<f32>, surface_normal: vec3<f32>, ior: f32, above:
     chunk_scene_database_access, chunk_mat3_inverse, chunk_water_lod_candidate, chunk_water_lod_layout,
     WATER_LOD_CANDIDATE_STRUCT.declaration_chunk, chunk_water_surface_sample]);
 
+for (const resource of [
+    CAMERA_RESOURCE, TRACE_RESOURCE, SCENE_DATABASE_RESOURCE, LOD_RESOURCE, LOD_LIMITS_RESOURCE, LOD_BODIES_RESOURCE,
+    LOD_CANDIDATES_RESOURCE, LOD_CELLS_RESOURCE, MESHLET_METADATA_RESOURCE,
+]) {
+    surface_body.requireResource(resource);
+}
+
 export const chunk_water_screen_ray = CodeChunk.from(/* language=WGSL */ `
 fn water_hzb_mip_size(depth_size: vec2f, hzb_size: vec2f, mip: i32) -> vec2f {
     if (mip <= 0) { return depth_size; }
@@ -400,6 +423,10 @@ fn water_hzb_hit(ray: Ray, budget: u32) -> ScreenSpaceRayHit {
 `, [chunk_screen_space_newton_ray, chunk_ffx_sssr_advance_ray, chunk_ffx_sssr_load_depth, chunk_project_direction,
     chunk_ray_at]);
 
+for (const resource of [CAMERA_RESOURCE, TRACE_RESOURCE, SCREEN_DEPTH_RESOURCE, SCREEN_HZB_RESOURCE, SCREEN_NORMAL_RESOURCE]) {
+    chunk_water_screen_ray.requireResource(resource);
+}
+
 const body = CodeChunk.from(/* language=WGSL */ `
 struct WaterReceiver {
     @location(0) receiver: vec4<f32>,
@@ -586,15 +613,14 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
 `, [surface_body, chunk_water_screen_ray, chunk_F_dielectric, chunk_ffx_sssr_validate_hit,
     chunk_direction_view_to_world, chunk_ray_at, chunk_water_optics, chunk_water_inscatter,
     chunk_water_receiver_downwelling, chunk_water_receiver_texel,
-    chunk_water_transport, chunk_water_receiver_radiance]);
+    chunk_water_transport, chunk_water_receiver_radiance,
+    // water_gi_specular here, and water_gi_irradiance for the in-scatter and the downwelling light
+    chunk_water_gi]);
 
 export const water_shader = ShaderDescriptor.from({ label: "Water / receivers", resources, body });
-/** The optics pass under IBL, and under LPV, which has no transparent variant. */
-export const water_finalize_shader_ibl = ShaderDescriptor.from({ label: 'Water / coherent optics IBL',
-    resources: WATER_FINALIZE_RESOURCES_IBL, body: CodeChunk.from('', [finalize_body, chunk_water_gi_ibl]) });
-/** The optics pass under Brick4. */
-export const water_finalize_shader_brick4 = ShaderDescriptor.from({ label: 'Water / coherent optics Brick4',
-    resources: WATER_FINALIZE_RESOURCES_BRICK4, body: CodeChunk.from('', [finalize_body, chunk_water_gi_brick4]) });
+/** The optics pass; its variants differ in the indirect lighting they fall back to, and bind alike. */
+export const water_finalize_shader = ShaderDescriptor.from({ label: 'Water / coherent optics',
+    resources: WATER_FINALIZE_RESOURCES, body: finalize_body });
 export const WATER_RESOURCES = resources;
 
 /** Nearest-interface selection writes only water-owned depth and optics, never opaque G-buffer. */
@@ -602,7 +628,7 @@ function water_pipeline(shader, targets, finalize) {
     const code = shader.source;
     const layout = shader.resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT);
     // The lattice spends eight storage slots in the vertex stage, the guaranteed budget. Lighting spends four in the
-    // fragment stage. Keep their visibility precise so the Brick4 variant fits it there.
+    // fragment stage, Brick4's buffer among them. Keep their visibility precise so the optics fit it there.
     const vertex_only = new Set(['lod', 'lod_limits', 'water_lod_bodies', 'water_lod_candidates', 'water_lod_cells',
         'meshlet_metadata', 'meshlet_data', 'water_band_displacement', 'water_particle_offsets', 'water_particle_entries']);
     // the fragment stage shades the bands the mesh could not carry
@@ -622,11 +648,7 @@ function water_pipeline(shader, targets, finalize) {
     });
 }
 export function create_water_pipeline() { return water_pipeline(water_shader, ['rgba32float', 'rgba32float'], false); }
-/** The optics pipeline under IBL, its shader built for `switches` (a ShaderSwitchSet). */
-export function create_water_finalize_pipeline_ibl(switches) {
-    return water_pipeline(water_finalize_shader_ibl.variant(switches), ['rgba32float', 'rgba16float', 'rgba16float'], true);
-}
-/** The optics pipeline under Brick4, its shader built for `switches` (a ShaderSwitchSet). */
-export function create_water_finalize_pipeline_brick4(switches) {
-    return water_pipeline(water_finalize_shader_brick4.variant(switches), ['rgba32float', 'rgba16float', 'rgba16float'], true);
+/** The optics pipeline, its shader built for `switches` (a ShaderSwitchSet). */
+export function create_water_finalize_pipeline(switches) {
+    return water_pipeline(water_finalize_shader.variant(switches), ['rgba32float', 'rgba16float', 'rgba16float'], true);
 }

package/src/shade/renderer/water/surface/GPUWaterSurface.d.ts

@@ -14,7 +14,10 @@ export class GPUWaterSurface {
     onInputsConsumed: Signal;
     /** Most wave particles alive at once over every body of a scene. */
     particle_capacity: number;
-    /** Whether any body has wind; without it the band tiles are not animated. */
+    /**
+     * Whether the scene's wind field can hold wind (set by whoever owns the bodies: `WaterSystem` asks the GPU fluid);
+     * without it the band tiles are not animated.
+     */
     windy: boolean;
     /**
      * Whether any splash was ever queued. Until one is, the pool is empty and no particle pass is recorded; set by

package/src/shade/renderer/water/surface/GPUWaterSurface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterSurface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterSurface.js"],"names":[],"mappings":"AAoBA,uHAAuH;AACvH,2CAA4C;AAE5C,4EAA4E;AAC5E,6DAKI;AAEJ;;;;;;GAMG;AACH;IACI,4FAA4F;IAC5F,yBAAgC;IAChC,oEAAoE;IACpE,0BAA0B;IAC1B,6EAA6E;IAC7E,eAAc;IACd;;;OAGG;IACH,kBAAiB;IAejB,mCAA0D;IAC1D,kCAAwD;IACxD,kCAA0D;IAC1D,kCAA0D;IAC1D,kHAAkH;IAClH,uBAAmC;IACnC,qGAAqG;IACrG,0BAAyC;IACzC,gHAAgH;IAChH,8BAA2D;IAC3D,mCAA2C;IAE3C;;;OAGG;IACH,YAFW,MAAM,QAKhB;IAED,gBAWC;IAuBD;;;;;;;;;;;OAWG;IACH;QAVsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QAC9D,MAAM;QACT,KAAK,EAArB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI;YACI,MAAM;YACE,UAAU,EAA1C,UAAU,MAAM,CAAC;YACI,MAAM,EAA3B,MAAM;;QACU,MAAM,EAAtB,MAAM;aAsEhB;;CACJ;kCArMiC,kDAAkD;mBAHjE,0CAA0C;kCAK3B,kCAAkC"}
+{"version":3,"file":"GPUWaterSurface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterSurface.js"],"names":[],"mappings":"AAoBA,uHAAuH;AACvH,2CAA4C;AAE5C,4EAA4E;AAC5E,6DAKI;AAEJ;;;;;;GAMG;AACH;IACI,4FAA4F;IAC5F,yBAAgC;IAChC,oEAAoE;IACpE,0BAA0B;IAC1B;;;OAGG;IACH,eAAc;IACd;;;OAGG;IACH,kBAAiB;IAejB,mCAA0D;IAC1D,kCAAwD;IACxD,kCAA0D;IAC1D,kCAA0D;IAC1D,kHAAkH;IAClH,uBAAmC;IACnC,qGAAqG;IACrG,0BAAyC;IACzC,gHAAgH;IAChH,8BAA2D;IAC3D,mCAA2C;IAE3C;;;OAGG;IACH,YAFW,MAAM,QAKhB;IAED,gBAWC;IAuBD;;;;;;;;;;;OAWG;IACH;QAVsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QAC9D,MAAM;QACT,KAAK,EAArB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI;YACI,MAAM;YACE,UAAU,EAA1C,UAAU,MAAM,CAAC;YACI,MAAM,EAA3B,MAAM;;QACU,MAAM,EAAtB,MAAM;aAyEhB;;CACJ;kCA3MiC,kDAAkD;mBAHjE,0CAA0C;kCAK3B,kCAAkC"}

package/src/shade/renderer/water/surface/GPUWaterSurface.js

@@ -41,7 +41,10 @@ export class GPUWaterSurface {
     onInputsConsumed = new Signal();
     /** Most wave particles alive at once over every body of a scene. */
     particle_capacity = 65536;
-    /** Whether any body has wind; without it the band tiles are not animated. */
+    /**
+     * Whether the scene's wind field can hold wind (set by whoever owns the bodies: `WaterSystem` asks the GPU fluid);
+     * without it the band tiles are not animated.
+     */
     windy = false;
     /**
      * Whether any splash was ever queued. Until one is, the pool is empty and no particle pass is recorded; set by
@@ -174,11 +177,14 @@ export class GPUWaterSurface {
                 }
             }
             if (groups > 0) {
-                shader_water_cull.dispatch({ encoder, bindings: {
+                const bindings = {
                     cull: encoder.allocateTransientValueBuffer(WATER_CULL_STRUCT, { dt, stepping: stepping ? 1 : 0, binning: binning ? 1 : 0 }),
                     lod: encoder.allocateTransientValueBuffer(WATER_LOD_VIEW_STRUCT, lod), camera: view.camera, scene_database: scene.scene_database_buffer, geometries: scene.geometries.buffer_metadata,
                     band_state, band_requests, particle_bounds, steep, activity, visible_rows: lists.visible, active_rows: lists.active,
-                    emit_rows: lists.emit }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+                    emit_rows: lists.emit };
+                // the bodies' wind: the scene's published field, read as its producer left it before this pass
+                scene.wind.bind(bindings);
+                shader_water_cull.dispatch({ encoder, bindings, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
             }
             finalize(encoder, { fresh: fresh && !seed ? 1 : 0, seed: 0 });
             if (windy) { spectrum(encoder); }