@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -0,0 +1,31 @@
+/**
+ * The scene's participating-media volumes, as rows of the scene database.
+ * @type {import("../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const PARTICIPATING_MEDIA_VOLUMES_TABLE: import("../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+/**
+ * Per-thread iteration over the scene's participating-media volumes, read from the scene database
+ * the importing shader binds as `scene_database` (`var<storage, read>`, `array<u32>`). No workgroup
+ * memory, so it serves the froxel passes and the ray passes alike.
+ *
+ * The table is written whole from row 0 — `GPUSceneVolumetrics` clears it and adds every volume in
+ * the scene's order — so its rows are `[0, count)`, its pages run from page 0 without a hole, and
+ * only the last of them is partly full. `participating_media_volumes_count` reads the count off the
+ * pages' live counts, stopping at the first page that is missing or not full: one page for up to
+ * {@link PARTICIPATING_MEDIA_VOLUMES_TABLE}'s `elements_per_page` volumes. A walk is then over rows,
+ * never over the table's page capacity:
+ *
+ *     let volume_count = participating_media_volumes_count(&scene_database);
+ *
+ *     for (var v = 0u; v < volume_count; v++) {
+ *         let volume = participating_media_volume_read(&scene_database, v);
+ *         // ...
+ *     }
+ *
+ * The page accessors stay for readers that walk the occupancy bitmap.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_volumes_iterate: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_participating_media_volumes_iterate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_participating_media_volumes_iterate.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_participating_media_volumes_iterate.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,gDAFU,OAAO,4CAA4C,EAAE,uBAAuB,CAEkB;AAExG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wDAFU,SAAS,CAsDjB;0BApFwB,iCAAiC"}

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

@@ -0,0 +1,86 @@
+import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+
+/**
+ * The scene's participating-media volumes, as rows of the scene database.
+ * @type {import("../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const PARTICIPATING_MEDIA_VOLUMES_TABLE = SCENE_DATABASE_SPEC.get('participating_media_volumes');
+
+/**
+ * Per-thread iteration over the scene's participating-media volumes, read from the scene database
+ * the importing shader binds as `scene_database` (`var<storage, read>`, `array<u32>`). No workgroup
+ * memory, so it serves the froxel passes and the ray passes alike.
+ *
+ * The table is written whole from row 0 — `GPUSceneVolumetrics` clears it and adds every volume in
+ * the scene's order — so its rows are `[0, count)`, its pages run from page 0 without a hole, and
+ * only the last of them is partly full. `participating_media_volumes_count` reads the count off the
+ * pages' live counts, stopping at the first page that is missing or not full: one page for up to
+ * {@link PARTICIPATING_MEDIA_VOLUMES_TABLE}'s `elements_per_page` volumes. A walk is then over rows,
+ * never over the table's page capacity:
+ *
+ *     let volume_count = participating_media_volumes_count(&scene_database);
+ *
+ *     for (var v = 0u; v < volume_count; v++) {
+ *         let volume = participating_media_volume_read(&scene_database, v);
+ *         // ...
+ *     }
+ *
+ * The page accessors stay for readers that walk the occupancy bitmap.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_volumes_iterate = CodeChunk.from(
+    //language=WGSL
+    `
+const PARTICIPATING_MEDIA_VOLUMES_PAGE_LIMIT: u32 = ${PARTICIPATING_MEDIA_VOLUMES_TABLE.page_limit}u;
+const PARTICIPATING_MEDIA_VOLUMES_OCCUPANCY_BITMAP_WORDS: u32 = ${PARTICIPATING_MEDIA_VOLUMES_TABLE.occupancy_bitmap_words}u;
+const PARTICIPATING_MEDIA_VOLUMES_ELEMENTS_PER_PAGE: u32 = ${PARTICIPATING_MEDIA_VOLUMES_TABLE.elements_per_page}u;
+
+fn participating_media_volumes_page_address(database: ptr<storage, array<u32>, read>, page_index: u32) -> u32 {
+    return database[page_index + ${PARTICIPATING_MEDIA_VOLUMES_TABLE.page_lookup_address}u];
+}
+
+fn participating_media_volumes_page_bitmap_word(database: ptr<storage, array<u32>, read>, page_address: u32, word_index: u32) -> u32 {
+    // page header: [u32 live_count][u32 bitmap[OCCUPANCY_BITMAP_WORDS]]
+    return database[page_address + 1u + word_index];
+}
+
+fn participating_media_volumes_slot_to_index(page_index: u32, in_page_slot: u32) -> u32 {
+    return page_index * PARTICIPATING_MEDIA_VOLUMES_ELEMENTS_PER_PAGE + in_page_slot;
+}
+
+fn participating_media_volume_read(database: ptr<storage, array<u32>, read>, index: u32) -> ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref} {
+    return ${PARTICIPATING_MEDIA_VOLUMES_TABLE.marshalling_method_read}(database, index);
+}
+
+// how many volumes the scene has, as rows [0, count)
+fn participating_media_volumes_count(database: ptr<storage, array<u32>, read>) -> u32 {
+    var count = 0u;
+
+    for (var page = 0u; page < PARTICIPATING_MEDIA_VOLUMES_PAGE_LIMIT; page++) {
+        let page_address = participating_media_volumes_page_address(database, page);
+
+        if (page_address == ~0u) {
+            break;
+        }
+
+        // page header: [u32 live_count]...
+        let live = database[page_address];
+
+        count += live;
+
+        if (live < PARTICIPATING_MEDIA_VOLUMES_ELEMENTS_PER_PAGE) {
+            break;
+        }
+    }
+
+    return count;
+}
+    `,
+    [
+        PARTICIPATING_MEDIA_VOLUMES_TABLE.chunk_read,
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+    ]
+);

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

@@ -1 +1 @@
-{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA0BA;;;;;;;;GAQG;AACH;IAH+B,KAAK;IACvB;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CA8DjE;AAqVD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAnB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;IAElD,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;;;;;;WAjKH,MAAM;cAAQ,MAAM;;;EA0VrE"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA0BA;;;;;;;;GAQG;AACH;IAH+B,KAAK;IACvB;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CA8DjE;AAoVD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAnB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;IAElD,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;;;;;;WAjKH,MAAM;cAAQ,MAAM;;;EAyVrE"}

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

@@ -151,8 +151,7 @@ function graph_integrate_participating_media({
                     camera: camera.buffer.buffer,
                     view: view.uniform_buffer.buffer,
                     volumetrics_metadata,
-                    scene_volumetrics_metadata: scene.volumetrics.metadata_buffer.buffer,
-                    scene_volumes: scene.volumetrics.table.buffer,
+                    scene_database: scene.scene_database_buffer,
                     tOutput0: output0.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
                     tOutput1: output1.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
                 }
@@ -600,8 +599,7 @@ export function graph_build_volumetrics({
                 tParticipatingMedia1: participating_media1.obtainView(),
 
                 // RDR2-style far-field march inputs (used beyond froxel_far)
-                scene_volumetrics_metadata: view.scene.volumetrics.metadata_buffer.buffer,
-                scene_volumes: view.scene.volumetrics.table.buffer,
+                scene_database: view.scene.scene_database_buffer,
                 light_data: lights.buffer_data,
                 tSunTransmittance: sun_transmittance_lut.obtainView(),
 

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":"AAsMA,yEAIE;8BArL4B,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":"AAqMA,yEAIE;8BApL4B,4BAA4B"}

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

@@ -26,8 +26,7 @@ import { chunk_cluster_depth_from_z_slice } from "../light/cluster/chunk_cluster
 import { chunk_compute_volume_fade_factor } from "./chunk_compute_volume_fade_factor.js";
 import { chunk_frustum_unit_box_coverage_multisample } from "./chunk_frustum_unit_box_coverage_multisample.js";
 import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
-import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
-import { SCENE_VOLUMETRICS_METADATA_STRUCT } from "./SCENE_VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -36,8 +35,7 @@ resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
-    .addUniform("scene_volumetrics_metadata", SCENE_VOLUMETRICS_METADATA_STRUCT)
-    .addStorageBuffer("scene_volumes", WebGPUArray.from(PARTICIPATING_MEDIA_VOLUME_STRUCT))
+    .addStorageBuffer("scene_database", WebGPUArray.u32)
     .addStorageTexture("tOutput0", "rgba16float", "3d", "write-only")
     .addStorageTexture("tOutput1", "rgba16float", "3d", "write-only")
 
@@ -104,9 +102,10 @@ fn main(
     var scattering_luma_sum = 0.0;
     var anisotropic_g = 0.0;
 
-    for(var i=0u; i < scene_volumetrics_metadata.instance_count; i++){
+    let volume_count = participating_media_volumes_count(&scene_database);
 
-        let volume = scene_volumes[i];
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
 
         // Transform froxel into volume's coordinate space. Points go world -> local through
         // transform_inverse, so planes go by the transpose of *its* inverse, which is just
@@ -165,7 +164,6 @@ fn main(
         anisotropic_g += volume.particle_spec.g * volume_scattering_luma;
         
         scattering_luma_sum += volume_scattering_luma;
-        
     }
     
     if(scattering_luma_sum != 0.0){
@@ -193,6 +191,7 @@ fn main(
         chunk_compute_volume_fade_factor,
         chunk_mat4_extract_scale,
         chunk_volumetrics_column_jitter,
+        chunk_participating_media_volumes_iterate,
     ]
 )
 

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

@@ -20,8 +20,7 @@ import { chunk_get_directional_light_info_by_index } from "../shader/chunk/light
 import { chunk_sky_lut_compute_uv } from "../atmosphere/chunk_sky_lut_compute_uv.js";
 import { chunk_calculate_multiscattering } from "./chunk_calculate_multiscattering.js";
 import { chunk_camera_ray_planar_depth_scale } from "./chunk_camera_ray_planar_depth_scale.js";
-import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
-import { SCENE_VOLUMETRICS_METADATA_STRUCT } from "./SCENE_VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -35,8 +34,7 @@ resources.createGroup()
     .addTexture("tVolumeLighting", "float", "3d") // pre-integrated volumetric light scattering
     // RDR2-style far field: beyond froxel_far the pass ray-marches the scene volumes directly,
     // lit by the directional sun + atmosphere (single scattering, no self-shadow).
-    .addUniform("scene_volumetrics_metadata", SCENE_VOLUMETRICS_METADATA_STRUCT)
-    .addStorageBuffer("scene_volumes", WebGPUArray.from(PARTICIPATING_MEDIA_VOLUME_STRUCT))
+    .addStorageBuffer("scene_database", WebGPUArray.u32)
     .addStorageBuffer("light_data", WebGPUArray.u32)
     .addTexture("tSunTransmittance", "float", "2d")
     .addSampler("sLinear")
@@ -65,9 +63,10 @@ fn far_sample_volumes(world_pos: vec3<f32>) -> FarVolumeSample {
     var g_weighted = 0.0;
     var scattering_luma = 0.0;
 
-    let count = scene_volumetrics_metadata.instance_count;
-    for (var i = 0u; i < count; i++) {
-        let volume = scene_volumes[i];
+    let volume_count = participating_media_volumes_count(&scene_database);
+
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
         let local = (volume.transform_inverse * vec4<f32>(world_pos, 1.0)).xyz;
         if (any(abs(local) > vec3<f32>(0.5))) {
             continue;
@@ -263,6 +262,7 @@ fn main(
         chunk_get_directional_light_info_by_index,
         chunk_sky_lut_compute_uv,
         chunk_calculate_multiscattering,
+        chunk_participating_media_volumes_iterate,
     ]
 )
 

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

@@ -1,6 +1,10 @@
 /** Production water channel. Only AVBOIT's shared resolve composites its radiance. */
 export class GPUWaterRenderer {
-    surfaces: any[];
+    scene: any;
+    body_count: number;
+    meshlet_capacity: number;
+    time: number;
+    waves: any;
     settings: {
         enabled: boolean;
         max_distance: number;
@@ -10,12 +14,20 @@ export class GPUWaterRenderer {
         mode: number;
         reflections: number;
         debug_view: number;
+        inscatter_segments: number;
+        tessellation_pixels: number;
     };
-    avboit_is_empty(): boolean;
+    /**
+     * The frame's water bodies table, recorded by whoever owns the surfaces at the head of the frame;
+     * each drawable surface carries its row as `body_index`.
+     * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
+     */
+    bodies: import("./medium/GPUWaterBodies.js").GPUWaterBodies | null;
+    avboit_is_empty(view: any): boolean;
     /** 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 }: {
+    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 }: {
         graph: any;
         view_ctx: any;
         camera: any;
@@ -24,6 +36,11 @@ export class GPUWaterRenderer {
         normal_texture: any;
         hzb_texture: any;
         environment_texture: any;
+        light_cluster_parameters: any;
+        light_cluster_lookup: any;
+        light_cluster_data: any;
+        shadowmap_atlas: any;
+        indirect_lighting_mode?: number;
     }): {
         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":"AAaA,sFAAsF;AACtF;IACI,gBAAc;IACd;;;;;;;;;MACiF;IAOjF,2BAEC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBAKC;IAED;;;;;;;;;;;MA4GC;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;IAQd,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBAKC;IAED;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}

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

@@ -1,29 +1,49 @@
-import { half_to_float_uint16 } from "../../../core/binary/half_to_float_uint16.js";
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
 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 { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
+import { build_indirect_draw_command } from "../gpu_primitive/indirect/build_indirect_draw_command.js";
+import { graph_water_tessellation } from "./surface/graph_water_tessellation.js";
+import { WATER_TESSELLATION_STRUCT, WATER_TILE_VERTEX_COUNT } from "./surface/chunk_water_tessellation.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { create_water_pipeline, create_water_finalize_pipeline, WATER_DRAW_STRUCT, WATER_TRACE_STRUCT,
-    WATER_RESOURCES, WATER_FINALIZE_RESOURCES } from "./shader_water.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,
+    WATER_TRACE_STRUCT, WATER_GRID_STRUCT } from "./shader_water.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";
 
 /** Production water channel. Only AVBOIT's shared resolve composites its radiance. */
 export class GPUWaterRenderer {
-    surfaces = [];
+    scene = null;
+    body_count = 0;
+    meshlet_capacity = 0;
+    time = 0;
+    waves = null;
     settings = { enabled: true, max_distance: 300, distance_tolerance: 0.15,
-        max_updates: 4, fallback_steps: 48, mode: 0, reflections: 1, debug_view: 0 };
+        max_updates: 4, fallback_steps: 48, mode: 0, reflections: 1, debug_view: 0, inscatter_segments: 4,
+        tessellation_pixels: 4 };
+    /**
+     * The frame's water bodies table, recorded by whoever owns the surfaces at the head of the frame;
+     * each drawable surface carries its row as `body_index`.
+     * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
+     */
+    bodies = null;
     #pipeline = create_water_pipeline();
-    #finalize_pipeline = create_water_finalize_pipeline();
+    #finalize_pipeline_ibl = create_water_finalize_pipeline_ibl();
+    #finalize_pipeline_brick4 = create_water_finalize_pipeline_brick4();
     #prepared = new WeakMap();
     #inspection = new WeakMap();
     #probe = null;
 
-    avboit_is_empty() {
-        return !this.settings.enabled || !this.surfaces.some(s => s.visible && s.height_texture !== null);
+    avboit_is_empty(view) {
+        // the authored state: whether there is water at all, not whether its surface was produced yet
+        return !this.settings.enabled || this.body_count === 0 || this.meshlet_capacity === 0
+            || (view !== undefined && view.scene.scene !== this.scene);
     }
 
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
@@ -53,18 +73,26 @@ export class GPUWaterRenderer {
     }
 
     avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture,
-        hzb_texture, environment_texture }) {
-        const surfaces = this.surfaces.filter(s => s.visible && s.height_texture !== null)
-            .map(s => ({ ...s, extent: s.extent.slice(), height_uv: s.height_uv.slice(),
-                color_deep: s.color_deep.slice(), color_shore: s.color_shore.slice(),
-                shore_transition: s.shore_transition.slice(), extinction: s.extinction.slice() }))
-            .sort((a, b) => a.entity - b.entity);
-        surfaces.forEach((surface, index) => { surface.surface_id = index + 1; });
+        hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data,
+        shadowmap_atlas, indirect_lighting_mode = ShadeIndirectLightingMode.IBL }) {
+        const scene = view_ctx.scene;
+        const meshlets = this.bodies.meshlets({ graph, view: view_ctx, camera, meshlet_capacity: this.meshlet_capacity });
         const settings = { ...this.settings };
         const probe = this.#probe;
         this.#probe = null;
         const resolution = Array.from(view_ctx.resolution);
-        const data = { resolution, frame_time: surfaces[0]?.time ?? 0 };
+        const pixels = Math.max(1, settings.tessellation_pixels);
+        // Jitter moves raster samples, not the mesh sampling the simulation. A jittered
+        // reference would change displaced geometry and normals even while waves are paused.
+        const tessellation = { resolution, pixels,
+            view_projection_matrix: Float32Array.from(view_ctx.camera.camera.view_projection_matrix) };
+        const patches = graph_water_tessellation({ graph, scene, camera, meshlets,
+            meshlet_capacity: this.meshlet_capacity, tessellation });
+        const data = { resolution, frame_time: this.time };
+        const wave_state = this.waves.buffer, wave_resolution = this.waves.grid_resolution;
+        const geometry_bindings = () => ({ scene_database: scene.scene_database_buffer,
+            meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data,
+            wave_state });
         const pipeline = this.#pipeline;
         const pass = graph.add("Water / receivers", data, (data, resources, context) => {
             const { encoder, graphics } = context;
@@ -75,14 +103,14 @@ export class GPUWaterRenderer {
                 tNormal: resources.get(data.normal).obtainView(),
                 tHZB: resources.get(data.hzb).obtainView(),
                 tScene: resources.get(data.color).obtainView(),
-                tEnvironment: resources.get(data.environment).obtainView(),
-                height_sampler: graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE),
             };
-            // Copies/uniform uploads must be encoded before opening the render pass.
-            const draws = surfaces.map(s => WATER_RESOURCES.generateBindings({ ...shared,
-                water: encoder.allocateTransientValueBuffer(WATER_DRAW_STRUCT, s),
-                terrain_height: graphics.textures.obtain(s.height_texture).obtainView(),
-            }, encoder));
+            const command = resources.get(data.command);
+            build_indirect_draw_command(graphics.device, `${WATER_TILE_VERTEX_COUNT}, input, 0, 0`,
+                encoder, resources.get(data.patch_count), command);
+            const bindings = WATER_RESOURCES.generateBindings({ ...shared, ...geometry_bindings(),
+                wave_grid: encoder.allocateTransientValueBuffer(WATER_GRID_STRUCT, { resolution: wave_resolution }),
+                water_tiles: resources.get(data.tiles), water_tile_sums: resources.get(data.sums),
+                tessellation: encoder.allocateTransientValueBuffer(WATER_TESSELLATION_STRUCT, tessellation) }, encoder);
             const render = encoder.constructRenderPass({ label: "Water / receivers", pipeline, bindings: [],
                 colorAttachments: [data.receiver, data.trace_metadata].map(handle => ({
                     view: resources.get(handle).obtainView(), loadOp: "clear", storeOp: "store", clearValue: [0,0,0,0],
@@ -90,15 +118,18 @@ export class GPUWaterRenderer {
                 depthStencilAttachment: { view: resources.get(data.interface_depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
                     depthLoadOp: "clear", depthStoreOp: "store", depthClearValue: 0 },
             });
-            for (const bindings of draws) { graphics.setPipelineBindings(render, pipeline, bindings); render.draw(6); }
+            graphics.setPipelineBindings(render, pipeline, bindings);
+            render.drawIndirect(command, 0);
             render.end();
         });
         for (const [name, handle] of Object.entries({ camera, color: color_texture, scene_depth: depth_texture,
-            normal: normal_texture, hzb: hzb_texture, environment: environment_texture })) { data[name] = pass.read(handle); }
+            normal: normal_texture, hzb: hzb_texture })) { data[name] = pass.read(handle); }
         const target = (name, format) => pass.create(`Water ${name}`, TextureResourceDescriptor.from({
             resolution, format, usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
                 | (probe !== null && format !== "depth32float" ? GPUTextureUsage.COPY_SRC : 0),
         }));
+        data.tiles = pass.read(patches.tiles); data.sums = pass.read(patches.sums); data.patch_count = pass.read(patches.count);
+        data.command = pass.create('Water draw command', BufferResourceDescriptor.from(16, GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT));
         // Keep the accepted UV and both paths at f32 precision through final shading.
         data.receiver = target("receiver", "rgba32float");
         data.trace_metadata = target("trace metadata", "rgba32float");
@@ -120,21 +151,36 @@ export class GPUWaterRenderer {
             inputs: { distance_field: horizontal }, output_resolution: visibility_resolution });
         data.visibility_distance = visibility_distance;
         const finalize_data = {};
-        const finalize_pipeline = this.#finalize_pipeline;
+        // 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;
         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),
                 tDepth: resources.get(d.scene_depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
                 tNormal: resources.get(d.normal).obtainView(), tHZB: resources.get(d.hzb).obtainView(),
-                tScene: resources.get(d.color).obtainView(), tEnvironment: resources.get(d.environment).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(),
-                height_sampler: graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE),
+                ...geometry_bindings(), water_tiles: resources.get(d.tiles), water_tile_sums: resources.get(d.sums),
+                tessellation: encoder.allocateTransientValueBuffer(WATER_TESSELLATION_STRUCT, tessellation),
+                wave_grid: encoder.allocateTransientValueBuffer(WATER_GRID_STRUCT, { resolution: wave_resolution }),
+                // the lights, as the transparent meshes bind them
+                light_data: view_ctx.scene.lights.buffer_data,
+                tEnvironment: resources.get(d.environment).obtainView(),
+                cluster_parameters: resources.get(d.light_cluster_parameters),
+                cluster_lookup: resources.get(d.light_cluster_lookup),
+                cluster_data: resources.get(d.light_cluster_data),
+                shadowmapAtlas: resources.get(d.shadowmap_atlas).obtainView(),
+                sCompareLinear: graphics.samplers.obtain(SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR),
             };
-            const draws = surfaces.map(s => WATER_FINALIZE_RESOURCES.generateBindings({...shared,
-                water: encoder.allocateTransientValueBuffer(WATER_DRAW_STRUCT, s),
-                terrain_height: graphics.textures.obtain(s.height_texture).obtainView(),
-            }, encoder));
+            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 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: [],
@@ -145,12 +191,15 @@ export class GPUWaterRenderer {
             render.setPipeline(graphics.render_pipelines.obtain(copy_pipeline)); render.record_pipeline(copy_pipeline);
             graphics.setPipelineBindings(render, copy_pipeline, copy_bindings); render.draw(3);
             render.setPipeline(graphics.render_pipelines.obtain(finalize_pipeline)); render.record_pipeline(finalize_pipeline);
-            for (const bindings of draws) { graphics.setPipelineBindings(render, finalize_pipeline, bindings); render.draw(6); }
+            graphics.setPipelineBindings(render, finalize_pipeline, bindings);
+            render.drawIndirect(resources.get(d.command), 0);
             render.end();
         });
-        for (const key of ['camera','scene_depth','normal','hzb','color','environment','receiver','trace_metadata','visibility_distance','interface_depth']) {
+        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','visibility_distance','interface_depth','tiles','sums','command']) {
             finalize_data[key] = finalize.read(data[key]);
         }
+        for (const [key, handle] of Object.entries({ environment: environment_texture, light_cluster_parameters,
+            light_cluster_lookup, light_cluster_data, shadowmap_atlas })) { finalize_data[key] = finalize.read(handle); }
         const optical_target = (name,format) => finalize.create(`Water ${name}`, TextureResourceDescriptor.from({
             resolution, format, usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
                 | (probe !== null ? GPUTextureUsage.COPY_SRC : 0),
@@ -239,7 +288,7 @@ export class GPUWaterRenderer {
                 try {
                     await buffer.mapAsync(GPUMapMode.READ);
                     const mapped = buffer.getMappedRange();
-                    const half = offset => Array.from(new Uint16Array(mapped, offset, 4), half_to_float_uint16);
+                    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];

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

@@ -0,0 +1,14 @@
+/**
+ * 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;
+/**
+ * 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;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_water_gi.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,56 @@
+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]);

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

@@ -1,5 +1,7 @@
+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;
 import { CodeChunk } from '../shader/compiler/CodeChunk.js';
 //# sourceMappingURL=chunk_water_transport.d.ts.map

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":"AAKA,0DAeG;AAEH,8CAoBG;AAIH,sDA+CoF;0BA7F1D,iCAAiC"}
+{"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;AAGH,mDAS6F;AAI7F,sDAmCoE;0BAxG1C,iCAAiC"}