@woosh/meep-engine 3.39.0 → 3.41.0

package/src/shade/renderer/water/medium/GPUWaterBodies.js

@@ -1,116 +1,64 @@
-import { assert } from "../../../../core/assert.js";
-import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
-import { shader_water_bodies_derive } from "./shader_water_bodies_derive.js";
-import { WATER_BODIES_STRUCT, WATER_BODY_CAPACITY } from "./WATER_BODIES_STRUCT.js";
-
-/**
- * An empty medium record, for the table's unused slots.
- */
-const EMPTY_MEDIUM = Object.freeze({
-    absorption: [0, 0, 0], priority: 0, lobe_count: 0,
-    lobes: [0, 1, 2, 3].map(() => ({ scattering: [0, 0, 0], kind: 0, p0: 0, p1: 0 })),
-});
-
-/**
- * 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.
- */
-export class GPUWaterBodies {
-    /**
-     * @type {GPUDevice|null}
-     */
-    #device = null;
-
-    /**
-     * @type {GPUBuffer|null}
-     */
-    #buffer = null;
-
-    #bytes = new ArrayBuffer(WATER_BODIES_STRUCT.size);
-
-    /**
-     * The table, or null before the first record.
-     * @returns {GPUBuffer|null}
-     */
-    get buffer() {
-        return this.#buffer;
-    }
-
-    dispose() {
-        this.#buffer?.destroy();
-        this.#buffer = null;
-        this.#device = null;
-    }
-
-    /**
-     * @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 }) {
-        assert.defined(graph, 'graph');
-        assert.defined(device, 'device');
-        assert.isArray(surfaces, 'surfaces');
-
-        if (device !== this.#device) {
-            this.dispose();
-            this.#device = device;
-            this.#buffer = device.createBuffer({
-                label: "Water / bodies",
-                size: WATER_BODIES_STRUCT.size,
-                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-            });
-        }
-
-        const ordered = surfaces.slice().sort((a, b) => a.entity - b.entity);
-
-        assert.lessThanOrEqual(ordered.length, WATER_BODY_CAPACITY, `at most ${WATER_BODY_CAPACITY} water bodies`);
-
-        const bodies = [];
-
-        for (let i = 0; i < WATER_BODY_CAPACITY; i++) {
-            const surface = ordered[i];
-
-            if (surface === undefined) {
-                bodies.push({
-                    medium: EMPTY_MEDIUM, ior: 1,
-                    backscattering: [0, 0, 0, 0], extinction: [0, 0, 0, 0], diffuse_transmittance: 0,
-                });
-                continue;
-            }
-
-            surface.body_index = i;
-
-            bodies.push({
-                medium: surface.medium.to_gpu_record(),
-                ior: surface.ior,
-                backscattering: [0, 0, 0, 0],
-                extinction: [0, 0, 0, 0],
-                diffuse_transmittance: 0,
-            });
-        }
-
-        write_gpu_typed_buffer({ count: ordered.length, bodies }, WATER_BODIES_STRUCT, this.#bytes, 0);
-
-        device.queue.writeBuffer(this.#buffer, 0, this.#bytes);
-
-        if (ordered.length === 0) {
-            // an empty table, still valid to bind; nothing to derive
-            return;
-        }
-
-        const buffer = this.#buffer;
-
-        const pass = graph.add("Water / bodies derive", {}, (data, resources, { encoder }) => {
-            shader_water_bodies_derive.dispatch({ encoder, bindings: { water_bodies: buffer } });
-        });
-
-        // fills a persistent buffer that later passes bind directly
-        pass.make_side_effect();
-    }
-}
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { round_up } from "../../../../core/math/round_up.js";
+import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { INDIRECT_COMPUTE_COMMAND_DESCRIPTOR } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import { shader_prefix_sum_to_command } from "../../rasterize/expand/mesh/shader_prefix_sum_to_command.js";
+import { shader_increment_count_by_prefix_sum } from "../../rasterize/expand/mesh/shader_increment_count_by_prefix_sum.js";
+import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
+import { shader_water_meshlet_counts, shader_water_meshlets_expand } from "./shader_water_meshlets.js";
+import { shader_water_bodies_derive, WORKGROUP_SIZE } from "./shader_water_bodies_derive.js";
+
+/** GPU work over the scene's water table; no per-body render commands or transient body uniforms. */
+export class GPUWaterBodies {
+    record({ graph, scene }) {
+        const table = scene.scene_database.get('water_bodies');
+        const groups = table.dispatch_group_count(WORKGROUP_SIZE);
+        if (groups === 0) { return; }
+        const pass = graph.add('Water / bodies derive', {}, (_data, _resources, { encoder }) => {
+            shader_water_bodies_derive.dispatch({ encoder, bindings: { scene_database: scene.scene_database_buffer },
+                group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+        });
+        pass.make_side_effect();
+    }
+
+    /** Ordered prefix expansion preserves equal-depth ownership, including after holes and reuse. */
+    meshlets({ graph, view, camera, meshlet_capacity }) {
+        const scene = view.scene, table = scene.scene_database.get('water_bodies');
+        const capacity = table.element_capacity;
+        const data = {};
+        const pass = graph.add('Water / meshlet counts', data, (d, resources, { encoder }) => {
+            const groups = table.dispatch_group_count(64);
+            shader_water_meshlet_counts.dispatch({ encoder, bindings: {
+                capacity: round_up(capacity, 4), camera: resources.get(d.camera), scene_database: scene.scene_database_buffer,
+                geometries: scene.geometries.buffer_metadata, counts: resources.get(d.counts),
+            }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+        });
+        data.camera = pass.read(camera);
+        // The shared scan reads vec4u blocks, including the padded final block.
+        const bytes = 16 + round_up(capacity, 4) * 4;
+        data.counts = pass.create('counts', BufferResourceDescriptor.from(bytes, GPUBufferUsage.STORAGE, 0, bytes));
+        const sums = graph_prefix_scan_csdldf({ graph, data: data.counts, element_max_count: capacity });
+        const command_data = {};
+        const command_pass = graph.add('Water / expand command', command_data, (d, resources, { encoder }) => {
+            shader_prefix_sum_to_command.dispatch({ encoder, bindings: {
+                prefix_sums: resources.get(d.sums), command: resources.get(d.command),
+            } });
+        });
+        command_data.sums = command_pass.read(sums);
+        const command = command_data.command = command_pass.create('command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
+        const expand_data = {};
+        const expand = graph.add('Water / expand meshlets', expand_data, (d, resources, { encoder }) => {
+            shader_water_meshlets_expand.dispatchIndirect({ encoder, command: resources.get(d.command), bindings: {
+                prefix_sums: resources.get(d.sums), output: resources.get(d.output),
+                scene_database: scene.scene_database_buffer, geometries: scene.geometries.buffer_metadata,
+            } });
+        });
+        expand_data.command = expand.read(command);
+        expand_data.sums = expand.read(sums);
+        expand_data.output = expand.create('meshlets', BufferResourceDescriptor.from(16 + meshlet_capacity * 8,
+            GPUBufferUsage.STORAGE, 0, 16));
+        const { output } = graph_compute_pass({ graph, shader: shader_increment_count_by_prefix_sum,
+            bindings: { prefix_sums: sums, output: expand_data.output } });
+        return output;
+    }
+}

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

@@ -1,23 +1,4 @@
-/**
- * Most water bodies a frame carries.
- * @type {number}
- */
-export const WATER_BODY_CAPACITY: number;
-/**
- * One body of water as the water passes read it (WATER_OPTICS_PLAN_2026_10_02.md §7.2): its optics,
- * and nothing about where it is — where a body's water is, is its mesh. The authored part is written
- * from the CPU each frame; the derived part is integrated on the GPU from the medium's own phase
- * functions right after, so the two can never disagree with what the path tracer samples.
- *
- * @type {WebGPUStruct}
- */
+/** A persistent scene row. Geometry and node refer to the shared scene resources. */
 export const WATER_BODY_STRUCT: WebGPUStruct;
-/**
- * Every body of a frame, as the uniform `water_bodies`. Uniform rather than storage because the water
- * optics pass binds it beside the light group, whose storage buffers spend the stage's budget.
- *
- * @type {WebGPUStruct}
- */
-export const WATER_BODIES_STRUCT: WebGPUStruct;
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 //# sourceMappingURL=WATER_BODIES_STRUCT.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"WATER_BODIES_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/WATER_BODIES_STRUCT.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH,gCAFU,YAAY,CAaN;AAEhB;;;;;GAKG;AACH,kCAFU,YAAY,CAKJ;6BAtCW,mCAAmC"}
+{"version":3,"file":"WATER_BODIES_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/WATER_BODIES_STRUCT.js"],"names":[],"mappings":"AAIA,qFAAqF;AACrF,6CAIgB;6BAPa,mCAAmC"}

package/src/shade/renderer/water/medium/WATER_BODIES_STRUCT.js

@@ -1,42 +1,10 @@
-import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
-import { f32, u32, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-
-/**
- * Most water bodies a frame carries.
- * @type {number}
- */
-export const WATER_BODY_CAPACITY = 16;
-
-/**
- * One body of water as the water passes read it (WATER_OPTICS_PLAN_2026_10_02.md §7.2): its optics,
- * and nothing about where it is — where a body's water is, is its mesh. The authored part is written
- * from the CPU each frame; the derived part is integrated on the GPU from the medium's own phase
- * functions right after, so the two can never disagree with what the path tracer samples.
- *
- * @type {WebGPUStruct}
- */
-export const WATER_BODY_STRUCT = WebGPUStruct.from({
-    /** what fills the body: absorption and scattering lobes, RGB 1/m */
-    medium: MEDIUM_STRUCT,
-    /** index of refraction relative to the air above */
-    ior: f32,
-    /** derived: backscattering b_b = Σ b_i · B_i, RGB 1/m, in xyz */
-    backscattering: vec4f,
-    /** derived: beam attenuation c = a + Σ b_i, RGB 1/m, in xyz; per-pixel code reads it rather than walk the lobes */
-    extinction: vec4f,
-    /** derived: hemispherical Fresnel transmittance into the water for a uniform sky */
-    diffuse_transmittance: f32,
-}, "WaterBody");
-
-/**
- * Every body of a frame, as the uniform `water_bodies`. Uniform rather than storage because the water
- * optics pass binds it beside the light group, whose storage buffers spend the stage's budget.
- *
- * @type {WebGPUStruct}
- */
-export const WATER_BODIES_STRUCT = WebGPUStruct.from({
-    count: u32,
-    bodies: WebGPUArray.from(WATER_BODY_STRUCT, WATER_BODY_CAPACITY),
-}, "WaterBodies");
+import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
+import { f32, u32, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/** A persistent scene row. Geometry and node refer to the shared scene resources. */
+export const WATER_BODY_STRUCT = WebGPUStruct.from({
+    geometry: u32, node: u32, wave: u32, roughness: f32, dirty: u32,
+    medium: MEDIUM_STRUCT, ior: f32,
+    backscattering: vec4f, extinction: vec4f, diffuse_transmittance: f32,
+}, "WaterBody");

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

@@ -0,0 +1,3 @@
+export const WATER_BODIES_TABLE: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+export const WATER_WAVES_TABLE: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+//# sourceMappingURL=chunk_water_bodies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_bodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/chunk_water_bodies.js"],"names":[],"mappings":"AACA,iHAA0E;AAC1E,gHAAwE"}

package/src/shade/renderer/water/medium/chunk_water_bodies.js

@@ -0,0 +1,3 @@
+import { SCENE_DATABASE_SPEC } from "../../scene/SCENE_DATABASE_SPEC.js";
+export const WATER_BODIES_TABLE = SCENE_DATABASE_SPEC.get('water_bodies');
+export const WATER_WAVES_TABLE = SCENE_DATABASE_SPEC.get('water_waves');

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

@@ -1,8 +1,4 @@
-/**
- * Fills the derived fields of every water body from its authored ones, one thread a body.
- *
- * @type {ComputeShader}
- */
+export const WORKGROUP_SIZE: 64;
 export const shader_water_bodies_derive: ComputeShader;
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_water_bodies_derive.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_water_bodies_derive.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/shader_water_bodies_derive.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,yCAFU,aAAa,CAepB;8BA7B2B,+BAA+B"}
+{"version":3,"file":"shader_water_bodies_derive.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/shader_water_bodies_derive.js"],"names":[],"mappings":"AASA,gCAAiC;AAIjC,uDAkBG;8BA/B2B,+BAA+B"}

package/src/shade/renderer/water/medium/shader_water_bodies_derive.js

@@ -1,30 +1,32 @@
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_water_medium_derived } from "./chunk_water_medium_derived.js";
-import { chunk_water_medium_scattering } from "./chunk_water_medium_scattering.js";
-import { WATER_BODIES_STRUCT, WATER_BODY_CAPACITY } from "./WATER_BODIES_STRUCT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer("water_bodies", WATER_BODIES_STRUCT, true);
-
-/**
- * Fills the derived fields of every water body from its authored ones, one thread a body.
- *
- * @type {ComputeShader}
- */
-export const shader_water_bodies_derive = ComputeShader.from({
-    label: "Water / bodies derive",
-    resources,
-    body: CodeChunk.from(/* language=WGSL */ `
-@compute @workgroup_size(${WATER_BODY_CAPACITY})
-fn main(@builtin(local_invocation_index) i: u32) {
-    if (i >= water_bodies.count) { return; }
-    let medium = water_bodies.bodies[i].medium;
-    water_bodies.bodies[i].backscattering = vec4<f32>(water_medium_backscattering(medium), 0.0);
-    water_bodies.bodies[i].extinction = vec4<f32>(medium.absorption + water_medium_scattering(medium), 0.0);
-    water_bodies.bodies[i].diffuse_transmittance = water_diffuse_fresnel_transmittance(water_bodies.bodies[i].ior);
-}
-`, [chunk_water_medium_derived, chunk_water_medium_scattering]),
-});
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_water_medium_derived } from "./chunk_water_medium_derived.js";
+import { chunk_water_medium_scattering } from "./chunk_water_medium_scattering.js";
+import { WATER_BODIES_TABLE as table } from "./chunk_water_bodies.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+
+export const WORKGROUP_SIZE = 64;
+const pg = table.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addStorageBuffer('scene_database', WebGPUArray.u32, true);
+export const shader_water_bodies_derive = ComputeShader.from({
+    label: "Water / bodies derive", resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(${WORKGROUP_SIZE})
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    if (!${pg}_setup(&scene_database, folded_workgroup_index(group), lane)) { return; }
+    let slot = ${pg}_slot_in_page(lane);
+    if (slot >= ${pg}_ELEMENTS_PER_PAGE || !${pg}_is_occupied(slot)) { return; }
+    var body = ${pg}_read(&scene_database, slot);
+    if (body.dirty == 0u) { return; }
+    body.backscattering = vec4f(water_medium_backscattering(body.medium), 0.0);
+    body.extinction = vec4f(body.medium.absorption + water_medium_scattering(body.medium), 0.0);
+    body.diffuse_transmittance = water_diffuse_fresnel_transmittance(body.ior);
+    body.dirty = 0u;
+    ${table.marshalling_method_write}(&scene_database, ${pg}_slot_to_index(slot), body);
+}
+`, [table.chunk_iterate(WORKGROUP_SIZE, true), table.chunk_write, chunk_water_medium_derived,
+        chunk_water_medium_scattering, chunk_folded_workgroup_index]),
+});

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

@@ -0,0 +1,4 @@
+export const shader_water_meshlet_counts: ComputeShader;
+export const shader_water_meshlets_expand: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_meshlets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/shader_water_meshlets.js"],"names":[],"mappings":"AAyBA,wDAsBkH;AAOlH,yDAcsF;8BAhExD,+BAA+B"}

package/src/shade/renderer/water/medium/shader_water_meshlets.js

@@ -0,0 +1,69 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_COLLECTION_STRUCT } from "../../rasterize/MESHLET_COLLECTION_STRUCT.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_lower_bound_branchless } from "../../shader/chunk/math/chunk_lower_bound_branchless.js";
+import { WATER_BODIES_TABLE as table, WATER_WAVES_TABLE } from "./chunk_water_bodies.js";
+import { chunk_aabb3_project } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_project.js";
+import { chunk_aabb3_intersects_frustum } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+import { chunk_array_to_aabb3 } from "../../shader/chunk/geometry/aabb3/chunk_array_to_aabb3.js";
+import { chunk_mat4_linear_determinant } from "../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+
+const pg = table.page_iterator_symbol_prefix(64);
+const counts_resources = new ShaderResourceSetDescriptor();
+counts_resources.setImmediate('capacity', u32);
+counts_resources.createGroup().addUniform('camera', CAMERA_UNIFORM_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('counts', COLLECTION_U32_STRUCT_READ, true);
+export const shader_water_meshlet_counts = ComputeShader.from({ label: 'Water / meshlet counts', resources: counts_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    if (all(group == vec3u(0)) && lane == 0u) { counts.count = capacity; }
+    if (!${pg}_setup(&scene_database, folded_workgroup_index(group), lane)) { return; }
+    let slot = ${pg}_slot_in_page(lane);
+    if (slot >= ${pg}_ELEMENTS_PER_PAGE || !${pg}_is_occupied(slot)) { return; }
+    let body = ${pg}_read(&scene_database, slot);
+    let geometry = geometries[body.geometry];
+    let node = scene_read_node(&scene_database, body.node);
+    if (abs(mat4_linear_determinant(node.global)) < 1e-20) { return; }
+    var box = geometry.bounding_box;
+    if (body.wave != ~0u) {
+        let displacement = ${WATER_WAVES_TABLE.marshalling_method_read}(&scene_database, body.wave).displacement_bounds;
+        box[1] += displacement.x; box[4] += displacement.y;
+    }
+    let bounds = aabb3_project(array_to_aabb3(box), node.global);
+    if (!aabb3_intersects_frustum(bounds, camera.frustum)) { return; }
+    counts.elements[${pg}_slot_to_index(slot)] = geometry.meshlets_count;
+}
+`, [table.chunk_iterate(64), WATER_WAVES_TABLE.chunk_read, chunk_scene_database_access, chunk_folded_workgroup_index,
+    chunk_aabb3_project, chunk_array_to_aabb3, chunk_aabb3_intersects_frustum, chunk_mat4_linear_determinant]) });
+
+const expand_resources = new ShaderResourceSetDescriptor();
+expand_resources.createGroup().addStorageBuffer('prefix_sums', COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('output', MESHLET_COLLECTION_STRUCT, true);
+export const shader_water_meshlets_expand = ComputeShader.from({ label: 'Water / expand meshlets', resources: expand_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 128u + lane;
+    let row = lower_bound_branchless(&prefix_sums.elements, i + 1u, prefix_sums.count);
+    if (row >= prefix_sums.count) { return; }
+    var previous = 0u;
+    if (row > 0u) { previous = prefix_sums.elements[row - 1u]; }
+    let body = ${table.marshalling_method_read}(&scene_database, row);
+    let geometry = geometries[body.geometry];
+    output.elements[i].index = geometry.meshlets_address + i - previous;
+    output.elements[i].mesh = row;
+}
+`, [table.chunk_read, chunk_folded_workgroup_index, chunk_lower_bound_branchless]) });

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,CAuFmF;0BAnH5E,oCAAoC"}
+{"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"}