@woosh/meep-engine 3.40.0 → 3.42.0

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

@@ -3,16 +3,18 @@ import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.
 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 { water_lod_view, WATER_LOD_VIEW_STRUCT } from "./surface/lod/WATER_LOD.js";
+import { WATER_LOD_LIMITS_STRUCT, WATER_LOD_PATCH_INDICES, WATER_LOD_STATISTICS_WORDS,
+    WaterLodCommand } from "./surface/lod/shader_water_lod.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.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_FINALIZE_RESOURCES_BRICK4, WATER_FINALIZE_RESOURCES_IBL, WATER_RESOURCES,
-    WATER_TRACE_STRUCT, WATER_GRID_STRUCT } from "./shader_water.js";
+    WATER_TRACE_STRUCT } from "./shader_water.js";
+import { WATER_BAND_SAMPLER } from "./surface/GPUWaterSurface.js";
 import { shader_water_background_copy, shader_water_debug, shader_water_draw,
     shader_water_occupancy, shader_water_splat, shader_water_confidence_seed,
     shader_water_confidence_x, shader_water_confidence_y } from "./shader_water_avboit.js";
@@ -39,6 +41,20 @@ export class GPUWaterRenderer {
     #prepared = new WeakMap();
     #inspection = new WeakMap();
     #probe = null;
+    /**
+     * What the lattice's per-frame lists may hold (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3). Grown from
+     * each view's totals, read back a frame or two later; a frame over a budget drops its tail until then.
+     */
+    lod_budgets = { candidates: 1 << 16, interior: 1 << 18, boundary: 1 << 16, patches: 1 << 12 };
+    /**
+     * The lists' totals as the last read back frame needed them: candidates, interior cells, boundary cells, triangles
+     * drawn as themselves, patches.
+     */
+    lod_totals = new Uint32Array(WATER_LOD_STATISTICS_WORDS);
+    /** Readback buffers for the lists' totals, idle ones first. */
+    #readbacks = [];
+    /** The patches' index buffer, one per device. */
+    #patch_indices = null;
 
     avboit_is_empty(view) {
         // the authored state: whether there is water at all, not whether its surface was produced yet
@@ -70,29 +86,100 @@ export class GPUWaterRenderer {
         this.#probe = null;
         this.#prepared = new WeakMap();
         this.#inspection = new WeakMap();
+        for (const readback of this.#readbacks) { readback.buffer.destroy(); }
+        this.#readbacks = [];
+        this.#patch_indices?.buffer.destroy();
+        this.#patch_indices = null;
+    }
+
+    /** The patches' indices on this device, made the first time a frame draws there. */
+    #patch_index_buffer(device) {
+        if (this.#patch_indices?.device !== device) {
+            this.#patch_indices?.buffer.destroy();
+            const buffer = device.createBuffer({ label: 'Water / lod patch indices', size: WATER_LOD_PATCH_INDICES.byteLength,
+                usage: GPUBufferUsage.INDEX, mappedAtCreation: true });
+            new Uint16Array(buffer.getMappedRange()).set(WATER_LOD_PATCH_INDICES);
+            buffer.unmap();
+            this.#patch_indices = { device, buffer };
+        }
+        return this.#patch_indices.buffer;
+    }
+
+    /** Keep a frame's totals and grow the budgets they outran, to the next power of two over a quarter more. */
+    #grow(totals) {
+        this.lod_totals.set(totals);
+        const budgets = this.lod_budgets;
+        // statistics words: candidates, interior, boundary, flat triangles (sized by the scene, not grown), patches
+        const keys = { candidates: 0, interior: 1, boundary: 2, patches: 4 };
+        for (const [key, i] of Object.entries(keys)) {
+            if (totals[i] > budgets[key]) { budgets[key] = 2 ** Math.ceil(Math.log2(totals[i] * 1.25)); }
+        }
+    }
+
+    /** After the lists are built, their totals to the CPU: at most three in flight, none if all are busy. */
+    #record_readback(graph, statistics) {
+        const data = {};
+        const pass = graph.add('Water / lod budgets', data, (d, resources, { encoder, graphics }) => {
+            // buffers of a device that has since been replaced go with it
+            this.#readbacks = this.#readbacks.filter(r => r.device === graphics.device || (r.buffer.destroy(), false));
+            let readback = this.#readbacks.find(r => !r.busy);
+            if (readback === undefined) {
+                if (this.#readbacks.length >= 3) { return; }
+                readback = { busy: false, device: graphics.device, buffer: graphics.device.createBuffer({ label: 'Water / lod budgets readback',
+                    size: WATER_LOD_STATISTICS_WORDS * 4, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST }) };
+                this.#readbacks.push(readback);
+            }
+            readback.busy = true;
+            encoder.copyBufferToBuffer(resources.get(d.statistics), 0, readback.buffer, 0, WATER_LOD_STATISTICS_WORDS * 4);
+            encoder.done.then(async () => {
+                try {
+                    await readback.buffer.mapAsync(GPUMapMode.READ);
+                    this.#grow(new Uint32Array(readback.buffer.getMappedRange()));
+                    readback.buffer.unmap();
+                } catch (error) {
+                    // a device lost or a buffer destroyed with the system: nothing to grow for
+                } finally { readback.busy = false; }
+            });
+        });
+        data.statistics = pass.read(statistics);
+        pass.make_side_effect();
     }
 
     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 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 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 surface = this.waves;
+        // the lattice is chosen from the camera's position and its pixel angle, not its jittered projection's offset:
+        // raster jitter moves samples, not the mesh
+        const lod = water_lod_view(view_ctx.camera.camera.projection_matrix, resolution[1], Math.max(0.5, settings.tessellation_pixels));
+        const { meshlets, lod_bodies } = this.bodies.meshlets({ graph, view: view_ctx, camera, meshlet_capacity: this.meshlet_capacity,
+            visible_rows: surface.visible_rows, lod, steep: surface.steep });
+        const limits = { ...this.lod_budgets, triangles: Math.max(this.meshlet_capacity, 1) * GEOMETRY_MESHLET_TRIANGLE_LIMIT };
+        const patches = graph_water_tessellation({ graph, scene, camera, meshlets, lod_bodies, meshlet_capacity: this.meshlet_capacity,
+            lod, limits, steep: surface.steep });
+        this.#record_readback(graph, patches.statistics);
         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,
+        // the surface interface: the band tiles and the frame's particle hash; and the view's lattice
+        const geometry_bindings = (graphics, encoder, resources, d) => ({ scene_database: scene.scene_database_buffer,
             meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data,
-            wave_state });
+            water_band_displacement: surface.displacement, water_band_derivatives: surface.derivatives,
+            water_band_sampler: graphics.samplers.obtain(WATER_BAND_SAMPLER),
+            water_particle_offsets: surface.particle_offsets, water_particle_entries: surface.particle_entries,
+            lod: encoder.allocateTransientValueBuffer(WATER_LOD_VIEW_STRUCT, lod),
+            lod_limits: encoder.allocateTransientValueBuffer(WATER_LOD_LIMITS_STRUCT, limits),
+            water_lod_bodies: resources.get(d.lod_bodies), water_lod_candidates: resources.get(d.candidates),
+            water_lod_cells: resources.get(d.cells) });
+        // the interior, boundary and triangle lists' draws, and the patches'
+        const draw = (render, commands, device) => {
+            for (let list = 0; list < 3; list++) { render.drawIndirect(commands, WaterLodCommand.Draws + 16 * list); }
+            render.setIndexBuffer(this.#patch_index_buffer(device), 'uint16');
+            render.drawIndexedIndirect(commands, WaterLodCommand.PatchDraw);
+        };
         const pipeline = this.#pipeline;
         const pass = graph.add("Water / receivers", data, (data, resources, context) => {
             const { encoder, graphics } = context;
@@ -104,13 +191,7 @@ export class GPUWaterRenderer {
                 tHZB: resources.get(data.hzb).obtainView(),
                 tScene: resources.get(data.color).obtainView(),
             };
-            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 bindings = WATER_RESOURCES.generateBindings({ ...shared, ...geometry_bindings(graphics, encoder, resources, data) }, 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],
@@ -119,7 +200,7 @@ export class GPUWaterRenderer {
                     depthLoadOp: "clear", depthStoreOp: "store", depthClearValue: 0 },
             });
             graphics.setPipelineBindings(render, pipeline, bindings);
-            render.drawIndirect(command, 0);
+            draw(render, resources.get(data.commands), graphics.device);
             render.end();
         });
         for (const [name, handle] of Object.entries({ camera, color: color_texture, scene_depth: depth_texture,
@@ -128,8 +209,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));
+        data.lod_bodies = pass.read(lod_bodies); data.candidates = pass.read(patches.candidates); data.cells = pass.read(patches.cells);
+        data.commands = pass.read(patches.commands);
         // 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");
@@ -164,9 +245,7 @@ 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(),
-                ...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 }),
+                ...geometry_bindings(graphics, encoder, resources, d),
                 // the lights, as the transparent meshes bind them
                 light_data: view_ctx.scene.lights.buffer_data,
                 tEnvironment: resources.get(d.environment).obtainView(),
@@ -192,10 +271,11 @@ export class GPUWaterRenderer {
             graphics.setPipelineBindings(render, copy_pipeline, copy_bindings); render.draw(3);
             render.setPipeline(graphics.render_pipelines.obtain(finalize_pipeline)); render.record_pipeline(finalize_pipeline);
             graphics.setPipelineBindings(render, finalize_pipeline, bindings);
-            render.drawIndirect(resources.get(d.command), 0);
+            draw(render, resources.get(d.commands), graphics.device);
             render.end();
         });
-        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','visibility_distance','interface_depth','tiles','sums','command']) {
+        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','visibility_distance','interface_depth',
+            'lod_bodies','candidates','cells','commands']) {
             finalize_data[key] = finalize.read(data[key]);
         }
         for (const [key, handle] of Object.entries({ environment: environment_texture, light_cluster_parameters,

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

@@ -1,15 +1,23 @@
-/** GPU work over the scene's water table; no per-body render commands or transient body uniforms. */
+/** A view's water bodies: which the view draws and how, and their meshlets in row order. */
 export class GPUWaterBodies {
-    record({ graph, scene }: {
-        graph: any;
-        scene: any;
-    }): void;
-    /** Ordered prefix expansion preserves equal-depth ownership, including after holes and reuse. */
-    meshlets({ graph, view, camera, meshlet_capacity }: {
+    /**
+     * Draw culling over the frame's visible list (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3), each drawn
+     * body's lattice frame at its row, and the drawn bodies' meshlets. The expansion is an ordered prefix scan over the
+     * rows, which preserves equal-depth ownership, including after holes and reuse.
+     *
+     * @returns {{meshlets: number, lod_bodies: number}} resources
+     */
+    meshlets({ graph, view, camera, meshlet_capacity, visible_rows, lod, steep }: {
         graph: any;
         view: any;
         camera: any;
         meshlet_capacity: any;
-    }): any;
+        visible_rows: any;
+        lod: any;
+        steep: any;
+    }): {
+        meshlets: number;
+        lod_bodies: number;
+    };
 }
 //# 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":"AAUA,qGAAqG;AACrG;IACI;;;aASC;IAED,iGAAiG;IACjG;;;;;YAsCC;CACJ"}
+{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAcA,4FAA4F;AAC5F;IACI;;;;;;OAMG;IACH;;;;;;;;QAFa;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA8ClD;CACJ"}

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

@@ -1,42 +1,47 @@
 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 {
+    build_indirect_compute_dispatch_command,
+    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";
+import { shader_water_meshlets_expand } from "./shader_water_meshlets.js";
+import { shader_water_lod_bodies } from "../surface/lod/shader_water_lod.js";
+import { WATER_LOD_BODY_STRUCT, WATER_LOD_VIEW_STRUCT } from "../surface/lod/WATER_LOD.js";
 
-/** GPU work over the scene's water table; no per-body render commands or transient body uniforms. */
+/** A view's water bodies: which the view draws and how, and their meshlets in row order. */
 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 }) {
+    /**
+     * Draw culling over the frame's visible list (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3), each drawn
+     * body's lattice frame at its row, and the drawn bodies' meshlets. The expansion is an ordered prefix scan over the
+     * rows, which preserves equal-depth ownership, including after holes and reuse.
+     *
+     * @returns {{meshlets: number, lod_bodies: number}} resources
+     */
+    meshlets({ graph, view, camera, meshlet_capacity, visible_rows, lod, steep }) {
         const scene = view.scene, table = scene.scene_database.get('water_bodies');
-        const capacity = table.element_capacity;
+        const capacity = Math.max(table.element_capacity, 1);
         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) });
+        const pass = graph.add('Water / lod bodies', data, (d, resources, { encoder }) => {
+            const command = resources.get(d.command);
+            build_indirect_compute_dispatch_command(64, encoder, visible_rows, 0, command, 0, true);
+            shader_water_lod_bodies.dispatchIndirect({ encoder, command, bindings: {
+                capacity: round_up(capacity, 4), lod: encoder.allocateTransientValueBuffer(WATER_LOD_VIEW_STRUCT, lod),
+                camera: resources.get(d.camera), scene_database: scene.scene_database_buffer,
+                geometries: scene.geometries.buffer_metadata, visible_rows, steep,
+                lod_bodies: resources.get(d.lod_bodies), counts: resources.get(d.counts),
+            } });
         });
         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));
+        data.command = pass.create('Water lod bodies command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
+        data.lod_bodies = pass.create('Water lod bodies', BufferResourceDescriptor.from(capacity * WATER_LOD_BODY_STRUCT.size,
+            GPUBufferUsage.STORAGE));
         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 }) => {
@@ -55,10 +60,10 @@ export class GPUWaterBodies {
         });
         expand_data.command = expand.read(command);
         expand_data.sums = expand.read(sums);
-        expand_data.output = expand.create('meshlets', BufferResourceDescriptor.from(16 + meshlet_capacity * 8,
+        expand_data.output = expand.create('meshlets', BufferResourceDescriptor.from(16 + Math.max(meshlet_capacity, 1) * 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;
+        return { meshlets: output, lod_bodies: data.lod_bodies };
     }
 }

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

@@ -1,4 +1,3 @@
-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

@@ -1 +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"}
+{"version":3,"file":"shader_water_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/shader_water_meshlets.js"],"names":[],"mappings":"AAgBA,yDAcsF;8BA3BxD,+BAA+B"}

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

@@ -1,4 +1,3 @@
-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";
@@ -6,46 +5,9 @@ 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]) });
+import { WATER_BODIES_TABLE as table } from "./chunk_water_bodies.js";
 
 const expand_resources = new ShaderResourceSetDescriptor();
 expand_resources.createGroup().addStorageBuffer('prefix_sums', COLLECTION_U32_STRUCT_READ)

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

@@ -1,7 +1,6 @@
 export function create_water_pipeline(): RenderPipelineDescriptor;
 export function create_water_finalize_pipeline_ibl(): RenderPipelineDescriptor;
 export function create_water_finalize_pipeline_brick4(): RenderPipelineDescriptor;
-export const WATER_GRID_STRUCT: WebGPUStruct;
 export const WATER_TRACE_STRUCT: WebGPUStruct;
 /** Optics under IBL (and LPV, which has no transparent variant): the lights and the environment. */
 export const WATER_FINALIZE_RESOURCES_IBL: ShaderResourceSetDescriptor;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAueA,kEAAuH;AACvH,+EAA+J;AAC/J,kFAAqK;AAlcrK,6CAAqF;AAErF,8CAKwB;AA0BxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAkHrE,+CA+EmB;AA2LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCA9cA,8DAA8D;6BAmB1E,gCAAgC;4CAJjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAwmBA,kEAAuH;AACvH,+EAA+J;AAC/J,kFAAqK;AA/jBrK,8CAKwB;AAiCxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAqOrE,+CA+EmB;AA6LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCA5kBA,8DAA8D;6BAmB1E,gCAAgC;4CAJjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}