@woosh/meep-engine 3.39.0 → 3.41.0

package/src/shade/renderer/texture/virtual/VTPhysicalSlots.js

@@ -0,0 +1,245 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * The slot bookkeeping of a physical page cache — a square grid of `page_size + 2*border` slots
+ * over an atlas — with no texture behind it: which slots are taken, when each was last touched,
+ * which may never be evicted, and the mip each holds.
+ *
+ * {@link VTPhysicalCache} adds the layer textures and uploads on top of this. A cache whose pages
+ * are drawn rather than uploaded — the virtual shadow map's pool is a region of the shadow atlas —
+ * uses it on its own.
+ *
+ * Eviction metadata lives here as flat parallel arrays; the pick is a linear scan, which at the
+ * typical slot count (≤ ~1k) is cheaper than maintaining a heap.
+ */
+export class VTPhysicalSlots {
+
+    /**
+     * Payload texels per page side, without border.
+     * @type {number}
+     * @readonly
+     */
+    page_size;
+
+    /**
+     * Border texels on each side of the payload.
+     * @type {number}
+     * @readonly
+     */
+    border;
+
+    /**
+     * page_size + 2*border.
+     * @type {number}
+     * @readonly
+     */
+    slot_size;
+
+    /**
+     * Atlas side length in texels.
+     * @type {number}
+     * @readonly
+     */
+    atlas_size;
+
+    /**
+     * Slots along one atlas axis.
+     * @type {number}
+     * @readonly
+     */
+    slots_per_axis;
+
+    /**
+     * Total slot count.
+     * @type {number}
+     * @readonly
+     */
+    capacity;
+
+    /**
+     * Free slot indices, used as a stack.
+     * @type {number[]}
+     */
+    #free = [];
+
+    /**
+     * Per-slot: frame index of the last feedback touch.
+     * @type {Uint32Array}
+     */
+    #last_touch;
+
+    /**
+     * Per-slot: 1 when the slot must never be evicted (stack root pages).
+     * @type {Uint8Array}
+     */
+    #locked;
+
+    /**
+     * Per-slot: 1 when the slot is allocated.
+     * @type {Uint8Array}
+     */
+    #occupied;
+
+    /**
+     * Per-slot: virtual mip of the resident page — eviction tie-break only
+     * (prefer shedding fine pages, shrinking the resident quadtree from the
+     * leaves).
+     * @type {Uint8Array}
+     */
+    #mip;
+
+    /**
+     *
+     * @param {Object} options
+     * @param {number} [options.atlas_size]
+     * @param {number} [options.page_size]
+     * @param {number} [options.border]
+     */
+    constructor({
+                    atlas_size = 4096,
+                    page_size = 128,
+                    border = 4,
+                }) {
+        assert.isNonNegativeInteger(atlas_size, 'atlas_size');
+        assert.isNonNegativeInteger(page_size, 'page_size');
+        assert.isNonNegativeInteger(border, 'border');
+
+        this.page_size = page_size;
+        this.border = border;
+        this.slot_size = page_size + border * 2;
+        this.atlas_size = atlas_size;
+
+        this.slots_per_axis = Math.floor(atlas_size / this.slot_size);
+        this.capacity = this.slots_per_axis * this.slots_per_axis;
+
+        assert.greaterThan(this.capacity, 0, 'cache capacity');
+
+        this.#last_touch = new Uint32Array(this.capacity);
+        this.#locked = new Uint8Array(this.capacity);
+        this.#occupied = new Uint8Array(this.capacity);
+        this.#mip = new Uint8Array(this.capacity);
+
+        for (let i = this.capacity - 1; i >= 0; i--) {
+            this.#free.push(i);
+        }
+    }
+
+    /**
+     * Number of allocated slots.
+     * @returns {number}
+     */
+    get used() {
+        return this.capacity - this.#free.length;
+    }
+
+    /**
+     *
+     * @param {number} slot
+     * @returns {{x: number, y: number}} slot grid coordinates
+     */
+    slot_coords(slot) {
+        return {
+            x: slot % this.slots_per_axis,
+            y: (slot / this.slots_per_axis) | 0,
+        };
+    }
+
+    /**
+     *
+     * @param {number} slot
+     * @returns {boolean}
+     */
+    is_occupied(slot) {
+        return this.#occupied[slot] === 1;
+    }
+
+    /**
+     *
+     * @param {number} current_frame
+     * @param {boolean} [locked]
+     * @param {number} [mip] virtual mip of the incoming page
+     * @returns {number} slot index, or -1 when full
+     */
+    allocate(current_frame, locked = false, mip = 0) {
+        if (this.#free.length === 0) {
+            return -1;
+        }
+
+        const slot = this.#free.pop();
+
+        this.#occupied[slot] = 1;
+        this.#locked[slot] = locked ? 1 : 0;
+        this.#last_touch[slot] = current_frame;
+        this.#mip[slot] = mip;
+
+        return slot;
+    }
+
+    /**
+     *
+     * @param {number} slot
+     */
+    free(slot) {
+        assert.equal(this.#occupied[slot], 1, `slot ${slot} is not allocated`);
+
+        this.#occupied[slot] = 0;
+        this.#locked[slot] = 0;
+
+        this.#free.push(slot);
+    }
+
+    /**
+     *
+     * @param {number} slot
+     * @param {number} frame
+     */
+    touch(slot, frame) {
+        this.#last_touch[slot] = frame;
+    }
+
+    /**
+     *
+     * @param {number} slot
+     * @returns {number}
+     */
+    last_touch(slot) {
+        return this.#last_touch[slot];
+    }
+
+    /**
+     * Pick the least-recently-touched evictable slot.
+     *
+     * @param {number} current_frame
+     * @param {number} protect_window slots touched within this many frames
+     *      are not eligible — feedback readback runs a couple of frames
+     *      behind, so "recently touched" really means "probably on screen"
+     * @returns {number} slot index, or -1 when nothing is evictable
+     */
+    find_eviction_candidate(current_frame, protect_window) {
+        let best = -1;
+        let best_touch = 0xFFFFFFFF;
+        let best_mip = 0xFF;
+
+        for (let slot = 0; slot < this.capacity; slot++) {
+            if (this.#occupied[slot] === 0 || this.#locked[slot] === 1) {
+                continue;
+            }
+
+            const touch = this.#last_touch[slot];
+
+            if (current_frame - touch < protect_window) {
+                continue;
+            }
+
+            const mip = this.#mip[slot];
+
+            if (touch < best_touch || (touch === best_touch && mip < best_mip)) {
+                best_touch = touch;
+                best_mip = mip;
+                best = slot;
+            }
+        }
+
+        return best;
+    }
+}

package/src/shade/renderer/texture/virtual/build_chunk_vt_lookup.d.ts

@@ -9,7 +9,7 @@
  *   vt_stack_wrap_uv(uv, flags)            — repeat/clamp addressing
  *   vt_mip_level(info, ddx, ddy)           — analytic LOD in virtual-texel units
  *   vt_page_table_load(table, info, uv, m) — one textureLoad into the shared table
- *   vt_entry_unpack(word)                  — page table entry fields
+ *   vt_entry_unpack(word)                  — page table entry fields, from {@link chunk_vt_page_table_entry}
  *   vt_physical_uv(entry, info, uv)        — atlas UV for a wrapped virtual UV
  *
  * The mip formula must be byte-identical between feedback and sampling —

package/src/shade/renderer/texture/virtual/build_chunk_vt_lookup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_chunk_vt_lookup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/build_chunk_vt_lookup.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAL0B,SAAS,EAAxB,MAAM;IACS,MAAM,EAArB,MAAM;IACS,UAAU,EAAzB,MAAM;IACJ,SAAS,CA2HrB;0BArJyB,oCAAoC"}
+{"version":3,"file":"build_chunk_vt_lookup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/build_chunk_vt_lookup.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAL0B,SAAS,EAAxB,MAAM;IACS,MAAM,EAArB,MAAM;IACS,UAAU,EAAzB,MAAM;IACJ,SAAS,CA2GrB;0BArIyB,oCAAoC"}

package/src/shade/renderer/texture/virtual/build_chunk_vt_lookup.js

@@ -1,5 +1,5 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { VT_ENTRY_MIP_BITS, VT_ENTRY_PHYS_BITS } from "./VT_CONSTANTS.js";
+import { chunk_vt_page_table_entry } from "./chunk_vt_page_table_entry.js";
 import { VT_STACK_INFO_STRUCT } from "./VT_STACK_INFO_STRUCT.js";
 
 /**
@@ -13,7 +13,7 @@ import { VT_STACK_INFO_STRUCT } from "./VT_STACK_INFO_STRUCT.js";
  *   vt_stack_wrap_uv(uv, flags)            — repeat/clamp addressing
  *   vt_mip_level(info, ddx, ddy)           — analytic LOD in virtual-texel units
  *   vt_page_table_load(table, info, uv, m) — one textureLoad into the shared table
- *   vt_entry_unpack(word)                  — page table entry fields
+ *   vt_entry_unpack(word)                  — page table entry fields, from {@link chunk_vt_page_table_entry}
  *   vt_physical_uv(entry, info, uv)        — atlas UV for a wrapped virtual UV
  *
  * The mip formula must be byte-identical between feedback and sampling —
@@ -41,23 +41,6 @@ const VT_INV_ATLAS_SIZE: f32 = ${(1 / atlas_size).toExponential()};
 const VT_STACK_FLAG_WRAP_REPEAT: u32 = 1u;
 const VT_STACK_FLAG_UV_SET_1: u32 = 2u;
 
-struct VTPageTableEntry {
-    phys: vec2<u32>,
-    mip: u32,
-    valid: bool,
-}
-
-fn vt_entry_unpack(word: u32) -> VTPageTableEntry {
-    return VTPageTableEntry(
-        vec2<u32>(
-            word & ${(1 << VT_ENTRY_PHYS_BITS) - 1}u,
-            (word >> ${VT_ENTRY_PHYS_BITS}u) & ${(1 << VT_ENTRY_PHYS_BITS) - 1}u
-        ),
-        (word >> ${VT_ENTRY_PHYS_BITS * 2}u) & ${(1 << VT_ENTRY_MIP_BITS) - 1}u,
-        (word & ${1 << (VT_ENTRY_PHYS_BITS * 2 + VT_ENTRY_MIP_BITS)}u) != 0u
-    );
-}
-
 fn vt_stack_wrap_uv(uv: vec2<f32>, flags: u32) -> vec2<f32> {
     if ((flags & VT_STACK_FLAG_WRAP_REPEAT) != 0u) {
         return fract(uv);
@@ -145,6 +128,7 @@ fn vt_physical_uv(
 `,
         [
             VT_STACK_INFO_STRUCT.declaration_chunk,
+            chunk_vt_page_table_entry,
         ]
     );
 }

package/src/shade/renderer/texture/virtual/chunk_vt_page_table_entry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The page-table entry word as its fields — the WGSL side of {@link vt_entry_pack} /
+ * {@link vt_entry_unpack}: the physical slot holding a page, the mip of that page, and whether the
+ * entry points at anything.
+ *
+ * Independent of any cache geometry, so it is shared by every table that stores entries in this
+ * layout — the virtual texture page table, and the virtual shadow map's page rows.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vt_page_table_entry: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vt_page_table_entry.d.ts.map

package/src/shade/renderer/texture/virtual/chunk_vt_page_table_entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_vt_page_table_entry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/chunk_vt_page_table_entry.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,wCAFU,SAAS,CAsBjB;0BAjCwB,oCAAoC"}

package/src/shade/renderer/texture/virtual/chunk_vt_page_table_entry.js

@@ -0,0 +1,34 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { VT_ENTRY_MIP_BITS, VT_ENTRY_PHYS_BITS } from "./VT_CONSTANTS.js";
+
+/**
+ * The page-table entry word as its fields — the WGSL side of {@link vt_entry_pack} /
+ * {@link vt_entry_unpack}: the physical slot holding a page, the mip of that page, and whether the
+ * entry points at anything.
+ *
+ * Independent of any cache geometry, so it is shared by every table that stores entries in this
+ * layout — the virtual texture page table, and the virtual shadow map's page rows.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vt_page_table_entry = CodeChunk.from(
+    //language=WGSL
+    `
+struct VTPageTableEntry {
+    phys: vec2<u32>,
+    mip: u32,
+    valid: bool,
+}
+
+fn vt_entry_unpack(word: u32) -> VTPageTableEntry {
+    return VTPageTableEntry(
+        vec2<u32>(
+            word & ${(1 << VT_ENTRY_PHYS_BITS) - 1}u,
+            (word >> ${VT_ENTRY_PHYS_BITS}u) & ${(1 << VT_ENTRY_PHYS_BITS) - 1}u
+        ),
+        (word >> ${VT_ENTRY_PHYS_BITS * 2}u) & ${(1 << VT_ENTRY_MIP_BITS) - 1}u,
+        (word & ${1 << (VT_ENTRY_PHYS_BITS * 2 + VT_ENTRY_MIP_BITS)}u) != 0u
+    );
+}
+`
+);

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;
@@ -11,6 +15,7 @@ export class GPUWaterRenderer {
         reflections: number;
         debug_view: number;
         inscatter_segments: number;
+        tessellation_pixels: number;
     };
     /**
      * The frame's water bodies table, recorded by whoever owns the surfaces at the head of the frame;
@@ -18,7 +23,7 @@ export class GPUWaterRenderer {
      * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
      */
     bodies: import("./medium/GPUWaterBodies.js").GPUWaterBodies | null;
-    avboit_is_empty(): boolean;
+    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;

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":"AAqCA,sFAAsF;AACtF;IACI,gBAAc;IACd;;;;;;;;;;MACwG;IACxG;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAQd,2BAGC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBAKC;IAED;;;;;;;;;;;;;;;;MA6HC;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,45 +1,32 @@
-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 { water_missing_receiver_path } from "./water_missing_receiver_path.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 { 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_DRAW_STRUCT, WATER_FINALIZE_RESOURCES_BRICK4, WATER_FINALIZE_RESOURCES_IBL, WATER_RESOURCES,
-    WATER_TRACE_STRUCT } from "./shader_water.js";
+    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";
 
-/**
- * A surface the water passes can draw: visible, and with its surface interface published by the
- * producer this frame.
- * @param {Object} s
- * @returns {boolean}
- */
-function water_surface_drawable(s) {
-    return s.visible && s.gpu_surface !== undefined;
-}
-
-/**
- * Draw a surface interface's mesh: the producer's index buffer over its vertex storage buffer.
- * @param {ShadeGPURenderPassEncoder} render
- * @param {{indices: GPUBuffer, index_count: number}} surface
- */
-function water_surface_draw(render, surface) {
-    render.setIndexBuffer(surface.indices, "uint32");
-    render.drawIndexed(surface.index_count);
-}
-
 /** 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, inscatter_segments: 4 };
+        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`.
@@ -53,9 +40,10 @@ export class GPUWaterRenderer {
     #inspection = new WeakMap();
     #probe = null;
 
-    avboit_is_empty() {
+    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.surfaces.some(s => s.visible);
+        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. */
@@ -87,16 +75,24 @@ 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 }) {
-        const surfaces = this.surfaces.filter(water_surface_drawable)
-            .map(s => ({ ...s, missing_receiver_path: water_missing_receiver_path({ medium: s.medium,
-                max_distance: this.settings.max_distance }) }))
-            .sort((a, b) => a.entity - b.entity);
-        surfaces.forEach((surface, index) => { surface.surface_id = index + 1; });
+        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;
@@ -108,11 +104,13 @@ export class GPUWaterRenderer {
                 tHZB: resources.get(data.hzb).obtainView(),
                 tScene: resources.get(data.color).obtainView(),
             };
-            // Copies/uniform uploads must be encoded before opening the render pass.
-            const draws = surfaces.map(s => ({ surface: s.gpu_surface, bindings: WATER_RESOURCES.generateBindings({ ...shared,
-                water: encoder.allocateTransientValueBuffer(WATER_DRAW_STRUCT, s),
-                surface_vertices: s.gpu_surface.vertices,
-            }, 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],
@@ -120,7 +118,8 @@ export class GPUWaterRenderer {
                 depthStencilAttachment: { view: resources.get(data.interface_depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
                     depthLoadOp: "clear", depthStoreOp: "store", depthClearValue: 0 },
             });
-            for (const draw of draws) { graphics.setPipelineBindings(render, pipeline, draw.bindings); water_surface_draw(render, draw.surface); }
+            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,
@@ -129,6 +128,8 @@ export class GPUWaterRenderer {
             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");
@@ -155,7 +156,6 @@ export class GPUWaterRenderer {
         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 bodies = this.bodies;
         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),
@@ -164,7 +164,9 @@ export class GPUWaterRenderer {
                 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(),
-                water_bodies: bodies?.buffer,
+                ...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(),
@@ -178,10 +180,7 @@ export class GPUWaterRenderer {
                 shared.brick4 = view_ctx.scene.volumetric_light_map.buffer;
                 shared.view = view_ctx.uniform_buffer.buffer;
             }
-            const draws = surfaces.map(s => ({ surface: s.gpu_surface, bindings: finalize_resources.generateBindings({...shared,
-                water: encoder.allocateTransientValueBuffer(WATER_DRAW_STRUCT, s),
-                surface_vertices: s.gpu_surface.vertices,
-            }, encoder) }));
+            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: [],
@@ -192,10 +191,11 @@ 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 draw of draws) { graphics.setPipelineBindings(render, finalize_pipeline, draw.bindings); water_surface_draw(render, draw.surface); }
+            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','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,
@@ -288,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_transport.js

@@ -76,12 +76,12 @@ fn water_receiver_path(depth: texture_2d<f32>, normals: texture_2d<u32>, uv: vec
     return distance(origin, screen_space_ray_lookup_position(uv, receiver, inverse_projection).xyz);
 }
 fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
-    uv: vec2f, inverse_projection: mat4x4f, inverse_view: mat4x4f, level: f32, below_interface: bool) -> vec4f {
+    uv: vec2f, inverse_projection: mat4x4f, inverse_view: mat4x4f, surface: vec3f, surface_normal: vec3f, below_interface: bool) -> vec4f {
     let size = vec2i(textureDimensions(depth, 0));
     let center = water_receiver_texel(depth, normals, clamp(vec2i(uv * vec2f(size)), vec2i(0), size-1),
         inverse_projection, inverse_view);
     if (is_background(center.depth)
-        || (below_interface && center.position.y > level + WATER_LEVEL_TOLERANCE)) { return vec4f(0.0); }
+        || (below_interface && dot(center.position - surface, surface_normal) > WATER_LEVEL_TOLERANCE)) { return vec4f(0.0); }
     let bilinear = get_bilinear_filter_uv(uv, vec2u(size));
     let base = vec2i(bilinear.origin);
     let f = bilinear.weights;
@@ -91,7 +91,7 @@ fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, norma
         for (var x = 0; x < 2; x++) {
             let coord = clamp(base + vec2i(x,y), vec2i(0), size-1);
             let tap = water_receiver_texel(depth, normals, coord, inverse_projection, inverse_view);
-            if (is_background(tap.depth) || (below_interface && tap.position.y > level + WATER_LEVEL_TOLERANCE)
+            if (is_background(tap.depth) || (below_interface && dot(tap.position - surface, surface_normal) > WATER_LEVEL_TOLERANCE)
                 || dot(center.normal, tap.normal) < 0.95
                 || abs(dot(tap.position - center.position, center.normal)) > 0.02) { continue; }
             let w = select(1.0-f.x, f.x, x == 1) * select(1.0-f.y, f.y, y == 1);

package/src/shade/renderer/water/medium/GPUWaterBodies.d.ts

@@ -1,29 +1,15 @@
-/**
- * The frame's water bodies on the GPU, as {@link WATER_BODIES_STRUCT}: one uniform buffer every
- * consumer of the water medium binds.
- *
- * Rebuilt each frame from the surfaces in entity order — the order the water passes draw in — and
- * each surface is told its row as `surface.body_index`. The derived fields are then integrated on
- * the GPU, in a pass recorded at the head of the frame, so everything recorded after reads them.
- */
+/** GPU work over the scene's water table; no per-body render commands or transient body uniforms. */
 export class GPUWaterBodies {
-    /**
-     * The table, or null before the first record.
-     * @returns {GPUBuffer|null}
-     */
-    get buffer(): any;
-    dispose(): void;
-    /**
-     * @param {Object} options
-     * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
-     * @param {GPUDevice} options.device
-     * @param {Object[]} options.surfaces
-     */
-    record({ graph, device, surfaces }: {
-        graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-        device: GPUDevice;
-        surfaces: any[];
+    record({ graph, scene }: {
+        graph: any;
+        scene: any;
     }): void;
-    #private;
+    /** Ordered prefix expansion preserves equal-depth ownership, including after holes and reuse. */
+    meshlets({ graph, view, camera, meshlet_capacity }: {
+        graph: any;
+        view: any;
+        camera: any;
+        meshlet_capacity: any;
+    }): any;
 }
 //# sourceMappingURL=GPUWaterBodies.d.ts.map

package/src/shade/renderer/water/medium/GPUWaterBodies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH;IAaI;;;OAGG;IACH,kBAEC;IAED,gBAIC;IAED;;;;;OAKG;IACH;QAJsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QAC9D,MAAM;QACP,QAAQ,EAA1B,KAAQ;aA8DlB;;CACJ"}
+{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAUA,qGAAqG;AACrG;IACI;;;aASC;IAED,iGAAiG;IACjG;;;;;YAsCC;CACJ"}