@woosh/meep-engine 3.39.0 → 3.41.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"WATER_WAVE_RECORD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/WATER_WAVE_RECORD_STRUCT.js"],"names":[],"mappings":"AAIA,kDAAkD;AAClD,0CAA2C;AAE3C,gFAAgF;AAChF,oDAcsB;6BApBO,mCAAmC"}

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

@@ -0,0 +1,23 @@
+import { f32, u32, vec2f, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/** Most impulses one body applies in one step. */
+export const WATER_WAVE_IMPULSE_LIMIT = 16;
+
+/** Persistent inputs; the shared dispatch owns timestep and grid resolution. */
+export const WATER_WAVE_RECORD_STRUCT = WebGPUStruct.from({
+    /** Local xz bounds; these describe the displacement field, not the water outline. */
+    extent: vec4f,
+    /** Local wind direction, world acceleration and drift speed. */
+    forcing: vec4f,
+    /** Local xz centre, world radius and velocity kick. */
+    impulses: WebGPUArray.from(vec4f, WATER_WAVE_IMPULSE_LIMIT),
+    node: u32,
+    unresolved_variance: f32,
+    impulse_count: u32,
+    first_write: u32,
+    geometry: u32,
+    /** GPU-owned signed local-y displacement bounds, reduced after simulation. */
+    displacement_bounds: vec2f,
+}, "WaterWaveRecord");

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

@@ -0,0 +1,9 @@
+export const WATER_TILE_CELLS: 16;
+export const WATER_TILE_VERTEX_COUNT: number;
+export const WATER_TILE_STRUCT: WebGPUStruct;
+export const WATER_TESSELLATION_STRUCT: WebGPUStruct;
+/** Clip in barycentric space: every generated point remains on the authored triangle. */
+export const chunk_water_tessellation: CodeChunk;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_water_tessellation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_tessellation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_tessellation.js"],"names":[],"mappings":"AAKA,kCAAmC;AAEnC,6CAAkE;AAClE,6CAEuB;AACvB,qDAE+B;AAE/B,yFAAyF;AACzF,iDA+H8B;6BA9ID,mCAAmC;0BADtC,oCAAoC"}

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

@@ -0,0 +1,144 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { f32, u32, vec2i, vec2u, vec2f, mat4x4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { chunk_barycentric_solve } from "../../shader/chunk/geometry/triangle/chunk_barycentric_solve.js";
+
+export const WATER_TILE_CELLS = 16;
+// A triangle clipped by five planes has at most eight corners, hence six fan triangles.
+export const WATER_TILE_VERTEX_COUNT = WATER_TILE_CELLS ** 2 * 18;
+export const WATER_TILE_STRUCT = WebGPUStruct.from({
+    meshlet: u32, triangle: u32, body: u32, anchor: f32, origin: vec2i, size: vec2u, pixels: f32,
+}, 'WaterTile').pack();
+export const WATER_TESSELLATION_STRUCT = WebGPUStruct.from({
+    resolution: vec2f, pixels: f32, view_projection_matrix: mat4x4f,
+}, 'WaterTessellation').pack();
+
+/** Clip in barycentric space: every generated point remains on the authored triangle. */
+export const chunk_water_tessellation = CodeChunk.from(/* language=WGSL */ `
+fn water_reference_position(position: vec3f, height: f32, simulated: bool) -> vec3f {
+    return vec3f(position.x, select(position.y, height, simulated), position.z);
+}
+// Bits identify the boundaries meeting at each corner: the three authored edges,
+// followed by the near plane and four cell edges. Retaining them lets reconstruction
+// evaluate an intersection directly, independent of the polygon clipping history.
+struct WaterPolygon { points: array<vec3f, 8>, boundaries: array<u32, 8>, count: u32 }
+fn water_triangle_polygon() -> WaterPolygon {
+    var p: WaterPolygon;
+    p.points[0] = vec3f(1,0,0); p.points[1] = vec3f(0,1,0); p.points[2] = vec3f(0,0,1); p.count = 3u;
+    p.boundaries[0] = 6u; p.boundaries[1] = 5u; p.boundaries[2] = 3u;
+    return p;
+}
+fn water_clip_polygon(p: WaterPolygon, distances: vec3f, boundary: u32) -> WaterPolygon {
+    var out: WaterPolygon;
+    if (p.count == 0u) { return out; }
+    var previous = p.points[p.count - 1u];
+    var d_previous = dot(previous, distances);
+    for (var i = 0u; i < p.count; i++) {
+        let current = p.points[i]; let d = dot(current, distances);
+        if ((d >= 0.0) != (d_previous >= 0.0)) {
+            let previous_index = select(i - 1u, p.count - 1u, i == 0u);
+            out.boundaries[out.count] = (p.boundaries[previous_index] & p.boundaries[i]) | boundary;
+            out.points[out.count] = mix(previous, current, d_previous / (d_previous - d)); out.count++;
+        }
+        if (d >= 0.0) { out.boundaries[out.count] = p.boundaries[i]; out.points[out.count] = current; out.count++; }
+        previous = current; d_previous = d;
+    }
+    return out;
+}
+fn water_plane_distances(a: vec4f, b: vec4f, c: vec4f, plane: vec4f) -> vec3f {
+    return vec3f(dot(a, plane), dot(b, plane), dot(c, plane));
+}
+fn water_point_weights(a: vec4f, b: vec4f, c: vec4f, point: vec2f) -> vec3f {
+    let w = vec3f(a.w,b.w,c.w);
+    return barycentric_solve(vec3f(a.x,b.x,c.x) - point.x * w, vec3f(a.y,b.y,c.y) - point.y * w);
+}
+fn water_authored_edges(weights: vec3f) -> u32 {
+    return select(0u,1u,weights.x == 0.0) | select(0u,2u,weights.y == 0.0) | select(0u,4u,weights.z == 0.0);
+}
+fn water_boundary_plane(boundary: u32, lo: vec2f, hi: vec2f) -> vec4f {
+    if ((boundary & 8u) != 0u) { return vec4f(0,0,-1,1); }
+    if ((boundary & 16u) != 0u) { return vec4f(1,0,0,-lo.x); }
+    if ((boundary & 32u) != 0u) { return vec4f(-1,0,0,hi.x); }
+    if ((boundary & 64u) != 0u) { return vec4f(0,1,0,-lo.y); }
+    return vec4f(0,-1,0,hi.y);
+}
+fn water_corner_weights(a: vec4f, b: vec4f, c: vec4f, boundaries: u32, lo: vec2f, hi: vec2f) -> vec3f {
+    if ((boundaries & 15u) == 0u) {
+        return water_point_weights(a,b,c,vec2f(select(lo.x,hi.x,(boundaries & 32u) != 0u),
+            select(lo.y,hi.y,(boundaries & 128u) != 0u)));
+    }
+    var distances: array<vec3f, 2>;
+    var count = 0u;
+    for (var bit = 0u; bit < 8u; bit++) {
+        if ((boundaries & (1u << bit)) == 0u) { continue; }
+        if (bit < 3u) { distances[count][bit] = 1.0; }
+        else { distances[count] = water_plane_distances(a,b,c,water_boundary_plane(1u << bit,lo,hi)); }
+        count++;
+        if (count == 2u) { break; }
+    }
+    return barycentric_solve(distances[0], distances[1]);
+}
+fn water_corner_position(a: vec3f, b: vec3f, c: vec3f, ca: vec4f, cb: vec4f, cc: vec4f,
+    weights: vec3f, boundaries: u32, lo: vec2f, hi: vec2f) -> vec3f {
+    let edges = boundaries & 7u;
+    if (edges == 6u) { return a; }
+    if (edges == 5u) { return b; }
+    if (edges == 3u) { return c; }
+    if (edges != 0u) {
+        var p = a; var q = b; var cp = ca; var cq = cb;
+        if (edges == 1u) { p = b; q = c; cp = cb; cq = cc; }
+        if (edges == 2u) { q = c; cq = cc; }
+        // Adjacent authored triangles traverse their common edge in opposite orders.
+        // Canonical endpoints and the original clipping plane give identical f32 positions.
+        if (p.x > q.x || (p.x == q.x && (p.y > q.y || (p.y == q.y && p.z > q.z)))) {
+            let tmp = p; p = q; q = tmp; let tc = cp; cp = cq; cq = tc;
+        }
+        // A cell corner may also lie on an authored edge coincident with a cell plane.
+        // Use the intersecting plane, rather than dividing by that coincident plane's zero span.
+        var dp = 0.0; var dq = 0.0;
+        for (var bit = 3u; bit < 8u; bit++) {
+            if ((boundaries & (1u << bit)) == 0u) { continue; }
+            let plane = water_boundary_plane(1u << bit,lo,hi);
+            let p_distance = dot(cp,plane); let q_distance = dot(cq,plane);
+            if (abs(p_distance - q_distance) > abs(dp - dq)) { dp = p_distance; dq = q_distance; }
+        }
+        return mix(p,q,dp / (dp - dq));
+    }
+    return a * weights.x + b * weights.y + c * weights.z;
+}
+fn water_cell_polygon(a: vec4f, b: vec4f, c: vec4f, lo: vec2f, hi: vec2f) -> WaterPolygon {
+    // Interior cells are ordinary quads. Reuse the rasterizer's homogeneous barycentric solve
+    // and reserve polygon clipping for the authored boundary and near-plane intersections.
+    if (a.w > 0.0 && b.w > 0.0 && c.w > 0.0 && a.w >= a.z && b.w >= b.z && c.w >= c.z) {
+        let p0 = water_point_weights(a,b,c,lo);
+        let p1 = water_point_weights(a,b,c,vec2f(hi.x,lo.y));
+        let p2 = water_point_weights(a,b,c,hi);
+        let p3 = water_point_weights(a,b,c,vec2f(lo.x,hi.y));
+        let minimum = min(min(p0,p1),min(p2,p3));
+        if (all(minimum >= vec3f(0))) {
+            var quad: WaterPolygon;
+            quad.points[0] = p0; quad.points[1] = p1; quad.points[2] = p2; quad.points[3] = p3;
+            quad.boundaries[0] = 80u | water_authored_edges(p0); quad.boundaries[1] = 96u | water_authored_edges(p1);
+            quad.boundaries[2] = 160u | water_authored_edges(p2); quad.boundaries[3] = 144u | water_authored_edges(p3);
+            // Preserve the source triangle's winding, just as the clipped path does.
+            // The rasterizer must identify the same side on interior and boundary cells.
+            if (dot(cross(a.xyw,b.xyw),c.xyw) < 0.0) {
+                quad.points[1] = p3; quad.points[3] = p1;
+                let boundary = quad.boundaries[1]; quad.boundaries[1] = quad.boundaries[3]; quad.boundaries[3] = boundary;
+            }
+            quad.count = 4u; return quad;
+        }
+    }
+    var p = water_triangle_polygon();
+    p = water_clip_polygon(p, water_plane_distances(a,b,c,vec4f(0,0,-1,1)), 8u);
+    p = water_clip_polygon(p, water_plane_distances(a,b,c,vec4f(1,0,0,-lo.x)), 16u);
+    p = water_clip_polygon(p, water_plane_distances(a,b,c,vec4f(-1,0,0,hi.x)), 32u);
+    p = water_clip_polygon(p, water_plane_distances(a,b,c,vec4f(0,1,0,-lo.y)), 64u);
+    p = water_clip_polygon(p, water_plane_distances(a,b,c,vec4f(0,-1,0,hi.y)), 128u);
+    for (var i = 0u; i < p.count; i++) {
+        p.points[i] = water_corner_weights(a,b,c,p.boundaries[i],lo,hi);
+        p.boundaries[i] |= water_authored_edges(p.points[i]);
+    }
+    return p;
+}
+`, [chunk_barycentric_solve]);

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

@@ -2,11 +2,9 @@
  * The primitive surface producer's physics, as pure functions so each is testable alone.
  *
  * A damped linear wave equation on a height field, `h_tt = c² ∇²h − γ h_t + f`, stepped by
- * leapfrog. The celerity is the shallow-water one, `c = √(g·d)`, so waves slow down and turn in
- * shallows and reflect from the shore. That is right for long waves and wrong for deep-water wind
- * waves, whose speed depends on their wavelength rather than on depth: a stated limit of a
- * primitive simulation, which the production simulation replaces behind the surface interface
- * (WATER_OPTICS_PLAN_2026_10_02.md §7.2).
+ * leapfrog. The celerity is the shallow-water one, `c = √(g·d)`. The batched producer uses a
+ * one-metre reference depth because an authored surface supplies no bathymetry. This primitive
+ * model describes long waves; deep-water wind waves have wavelength-dependent speed.
  *
  * @type {CodeChunk}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_wave.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_wave.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,+BAFU,SAAS,CAmChB;0BA/CuB,oCAAoC"}
+{"version":3,"file":"chunk_water_wave.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_wave.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,+BAFU,SAAS,CA6BhB;0BAvCuB,oCAAoC"}

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

@@ -1,48 +1,40 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * The primitive surface producer's physics, as pure functions so each is testable alone.
- *
- * A damped linear wave equation on a height field, `h_tt = c² ∇²h − γ h_t + f`, stepped by
- * leapfrog. The celerity is the shallow-water one, `c = √(g·d)`, so waves slow down and turn in
- * shallows and reflect from the shore. That is right for long waves and wrong for deep-water wind
- * waves, whose speed depends on their wavelength rather than on depth: a stated limit of a
- * primitive simulation, which the production simulation replaces behind the surface interface
- * (WATER_OPTICS_PLAN_2026_10_02.md §7.2).
- *
- * @type {CodeChunk}
- */
-export const chunk_water_wave = CodeChunk.from(/* language=WGSL */ `
-const WATER_WAVE_GRAVITY: f32 = 9.81;
-
-// Squared celerity of a long wave over water depth metres deep, capped so an explicit step of the
-// size the producer takes stays stable (2-D CFL: c·dt/dx ≤ 1/√2).
-fn water_wave_celerity2(depth: f32, celerity_limit: f32) -> f32 {
-    return min(WATER_WAVE_GRAVITY * max(depth, 0.0), celerity_limit * celerity_limit);
-}
-
-// One leapfrog step of h_tt = c² ∇²h − γ h_t + f: the next height from the current one, the
-// previous one, the current height's Laplacian, c², the damping rate γ (1/s), the forcing f (m/s²)
-// and the step dt (s).
-fn water_wave_step(h: f32, h_previous: f32, laplacian: f32, celerity2: f32, damping: f32,
-    force: f32, dt: f32) -> f32 {
-    return h + (h - h_previous) * max(1.0 - damping * dt, 0.0) + dt * dt * (celerity2 * laplacian + force);
-}
-
-// Extra damping in a band along the grid's border, rising quadratically to strength at the edge,
-// so waves leave the domain instead of reflecting off the end of the grid.
-fn water_wave_sponge(cell: vec2<u32>, resolution: u32, width: f32, strength: f32) -> f32 {
-    let last = f32(resolution - 1u);
-    let p = vec2<f32>(cell);
-    let edge = min(min(p.x, p.y), min(last - p.x, last - p.y));
-    let s = clamp(1.0 - edge / max(width, 1.0), 0.0, 1.0);
-    return strength * s * s;
-}
-
-// Unit normal of a height field from central differences of its heights at the four neighbours,
-// spacing metres apart.
-fn water_wave_normal(left: f32, right: f32, down: f32, up: f32, spacing: f32) -> vec3<f32> {
-    let slope = vec2<f32>(right - left, up - down) / (2.0 * spacing);
-    return normalize(vec3<f32>(-slope.x, 1.0, -slope.y));
-}
-`);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The primitive surface producer's physics, as pure functions so each is testable alone.
+ *
+ * A damped linear wave equation on a height field, `h_tt = c² ∇²h − γ h_t + f`, stepped by
+ * leapfrog. The celerity is the shallow-water one, `c = √(g·d)`. The batched producer uses a
+ * one-metre reference depth because an authored surface supplies no bathymetry. This primitive
+ * model describes long waves; deep-water wind waves have wavelength-dependent speed.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_wave = CodeChunk.from(/* language=WGSL */ `
+const WATER_WAVE_GRAVITY: f32 = 9.81;
+
+// Squared celerity of a long wave over water depth metres deep, capped so an explicit step of the
+// size the producer takes stays stable (2-D CFL: c·dt/dx ≤ 1/√2).
+fn water_wave_celerity2(depth: f32, celerity_limit: f32) -> f32 {
+    return min(WATER_WAVE_GRAVITY * max(depth, 0.0), celerity_limit * celerity_limit);
+}
+
+// One leapfrog step of h_tt = c² ∇²h − γ h_t + f: the next height from the current one, the
+// previous one, the current height's Laplacian, c², the damping rate γ (1/s), the forcing f (m/s²)
+// and the step dt (s).
+fn water_wave_step(h: f32, h_previous: f32, laplacian: f32, celerity2: f32, damping: f32,
+    force: f32, dt: f32) -> f32 {
+    return h + (h - h_previous) * max(1.0 - damping * dt, 0.0) + dt * dt * (celerity2 * laplacian + force);
+}
+
+// Extra damping in a band along the grid's border, rising quadratically to strength at the edge,
+// so waves leave the domain instead of reflecting off the end of the grid.
+fn water_wave_sponge(cell: vec2<u32>, resolution: u32, width: f32, strength: f32) -> f32 {
+    let last = f32(resolution - 1u);
+    let p = vec2<f32>(cell);
+    let edge = min(min(p.x, p.y), min(last - p.x, last - p.y));
+    let s = clamp(1.0 - edge / max(width, 1.0), 0.0, 1.0);
+    return strength * s * s;
+}
+
+`);

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

@@ -0,0 +1,14 @@
+/** Storage grows with source primitives; patch instances are expanded by the vertex shader. */
+export function graph_water_tessellation({ graph, scene, camera, meshlets, meshlet_capacity, tessellation }: {
+    graph: any;
+    scene: any;
+    camera: any;
+    meshlets: any;
+    meshlet_capacity: any;
+    tessellation: any;
+}): {
+    tiles: any;
+    sums: number;
+    count: any;
+};
+//# sourceMappingURL=graph_water_tessellation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_water_tessellation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/graph_water_tessellation.js"],"names":[],"mappings":"AAQA,+FAA+F;AAC/F;;;;;;;;;;;EAwBC"}

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

@@ -0,0 +1,34 @@
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
+import { shader_increment_count_by_prefix_sum } from "../../rasterize/expand/mesh/shader_increment_count_by_prefix_sum.js";
+import { WATER_TILE_STRUCT, WATER_TESSELLATION_STRUCT } from "./chunk_water_tessellation.js";
+import { shader_water_tiles } from "./shader_water_tiles.js";
+
+/** Storage grows with source primitives; patch instances are expanded by the vertex shader. */
+export function graph_water_tessellation({ graph, scene, camera, meshlets, meshlet_capacity, tessellation }) {
+    const capacity = meshlet_capacity * GEOMETRY_MESHLET_TRIANGLE_LIMIT;
+    const data = {};
+    const pass = graph.add('Water / classify view tiles', data, (d, resources, { encoder }) => {
+        const groups = Math.ceil(capacity / 128);
+        shader_water_tiles.dispatch({ encoder, bindings: {
+            capacity, camera: resources.get(d.camera), water_meshlets: resources.get(d.meshlets),
+            tessellation: encoder.allocateTransientValueBuffer(WATER_TESSELLATION_STRUCT, tessellation),
+            scene_database: scene.scene_database_buffer,
+            geometries: scene.geometries.buffer_metadata,
+            meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data,
+            counts: resources.get(d.counts), tiles: resources.get(d.tiles),
+        }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+    });
+    data.camera = pass.read(camera); data.meshlets = pass.read(meshlets);
+    data.tiles = pass.create('Water triangle tiles', BufferResourceDescriptor.from(capacity * WATER_TILE_STRUCT.size, GPUBufferUsage.STORAGE));
+    const bytes = 16 + capacity * 4;
+    data.counts = pass.create('Water tile counts', BufferResourceDescriptor.from(bytes, GPUBufferUsage.STORAGE, 0, bytes));
+    const sums = graph_prefix_scan_csdldf({ graph, data: data.counts, element_max_count: capacity });
+    const clear = graph.add('Water / patch count', {}, () => {});
+    const count = clear.create('Water patches', BufferResourceDescriptor.from(16, GPUBufferUsage.STORAGE, 0, 16));
+    const { output } = graph_compute_pass({ graph, shader: shader_increment_count_by_prefix_sum,
+        bindings: { prefix_sums: sums, output: count } });
+    return { tiles: data.tiles, sums, count: output };
+}

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

@@ -0,0 +1,4 @@
+/** Keep triangle identity, including hidden bodies. Only displaced raster depth selects ownership. */
+export const shader_water_tiles: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_tiles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_tiles.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_tiles.js"],"names":[],"mappings":"AA4BA,sGAAsG;AACtG,+CA6FmG;8BApHrE,+BAA+B"}

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

@@ -0,0 +1,123 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.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 { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.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_read_meshlet_vertex_by_draw_index } from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
+import { WATER_BODIES_TABLE, WATER_WAVES_TABLE } from "../medium/chunk_water_bodies.js";
+import { chunk_water_tessellation, WATER_TILE_CELLS, WATER_TILE_STRUCT, WATER_TESSELLATION_STRUCT } from "./chunk_water_tessellation.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.setImmediate('capacity', u32);
+resources.createGroup().addUniform('camera', CAMERA_UNIFORM_STRUCT).addUniform('tessellation', WATER_TESSELLATION_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('water_meshlets', MESHLET_COLLECTION_STRUCT)
+    .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT))
+    .addStorageBuffer('meshlet_data', WebGPUArray.from(f32))
+    .addStorageBuffer('tiles', WebGPUArray.from(WATER_TILE_STRUCT), true)
+    .addStorageBuffer('counts', COLLECTION_U32_STRUCT_READ, true);
+
+/** Keep triangle identity, including hidden bodies. Only displaced raster depth selects ownership. */
+export const shader_water_tiles = ComputeShader.from({ label: 'Water / classify view tiles', 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;
+    if (i == 0u) { counts.count = capacity; }
+    if (i >= capacity) { return; }
+    counts.elements[i] = 0u;
+    let meshlet_slot = i / ${GEOMETRY_MESHLET_TRIANGLE_LIMIT}u;
+    if (meshlet_slot >= water_meshlets.count) { return; }
+    let definition = water_meshlets.elements[meshlet_slot];
+    let triangle = i % ${GEOMETRY_MESHLET_TRIANGLE_LIMIT}u;
+    let header = meshlet_metadata[definition.index];
+    if (triangle >= header.primitive_count) { return; }
+    let body = ${WATER_BODIES_TABLE.marshalling_method_read}(&scene_database, definition.mesh);
+    let node = scene_read_node(&scene_database, body.node);
+    let simulated = body.wave != ~0u;
+    var bounds = vec2f(0);
+    if (simulated) { bounds = ${WATER_WAVES_TABLE.marshalling_method_read}(&scene_database, body.wave).displacement_bounds; }
+    // Increasing near-plane distance is farther from the camera. Use the far endpoint;
+    // clipping it at the near plane cannot discard a point displaced into the visible frustum.
+    let direction = tessellation.view_projection_matrix * node.global[1];
+    let farther = direction.w - direction.z >= 0.0;
+    var anchor = 0.0;
+    var pixels = tessellation.pixels;
+    if (simulated) {
+        let box = geometries[body.geometry].bounding_box;
+        // A shared local-xz reference keeps adjacent triangles' generated edge vertices
+        // identical, including sloped rest geometry. Only reconstruction flattens height;
+        // rendered vertices still interpolate all three authored position coordinates.
+        anchor = select(box[1] + bounds.x, box[4] + bounds.y, farther);
+        let x = tessellation.view_projection_matrix * node.global[0];
+        let z = tessellation.view_projection_matrix * node.global[2];
+        let origin = tessellation.view_projection_matrix * node.global[3];
+        let plane = cross(x.xyw, z.xyw);
+        let reference = origin + direction * anchor;
+        let span = box[4] - box[1] + bounds.y - bounds.x;
+        if (span > 0.0 && abs(dot(plane, reference.xyw)) <= 1e-5 * length(plane) * max(length(reference.xyw), 1.0)
+            && abs(dot(plane, direction.xyw)) > 1e-20) {
+            anchor += select(-span, span, farther);
+        }
+        var minimum_w = 1e30;
+        for (var corner = 0u; corner < 4u; corner++) {
+            let p = vec3f(select(box[0], box[3], (corner & 1u) != 0u), anchor, select(box[2], box[5], (corner & 2u) != 0u));
+            minimum_w = min(minimum_w, (tessellation.view_projection_matrix * (node.global * vec4f(p, 1))).w);
+        }
+        let low = box[1] + bounds.x - anchor;
+        let high = box[4] + bounds.y - anchor;
+        let slopes = vec4f(direction.w + direction.x, direction.w - direction.x, direction.w + direction.y, direction.w - direction.y);
+        let allowance = max(vec4f(0), max(slopes * low, slopes * high));
+        // After swept side-plane clipping, the reference's NDC span is at most
+        // 2 + (left + right allowance)/minimum_w. Use this body-wide bound so a
+        // near-plane envelope cannot amplify patches or split shared edge grids.
+        let amplification = 1.0 + max(allowance.x + allowance.y, allowance.z + allowance.w)
+            / (2.0 * max(camera.clip_near_far.x, minimum_w));
+        pixels *= amplification;
+    }
+    let pa = read_meshlet_vertex_by_draw_index(header, triangle * 3u).position;
+    let pb = read_meshlet_vertex_by_draw_index(header, triangle * 3u + 1u).position;
+    let pc = read_meshlet_vertex_by_draw_index(header, triangle * 3u + 2u).position;
+    let a = tessellation.view_projection_matrix * (node.global * vec4f(water_reference_position(pa, anchor, simulated), 1));
+    let b = tessellation.view_projection_matrix * (node.global * vec4f(water_reference_position(pb, anchor, simulated), 1));
+    let c = tessellation.view_projection_matrix * (node.global * vec4f(water_reference_position(pc, anchor, simulated), 1));
+    let heights = select(vec3f(0), vec3f(pa.y, pb.y, pc.y) - vec3f(anchor), simulated);
+    var p = water_clip_polygon(water_triangle_polygon(), water_plane_distances(a,b,c,vec4f(0,0,-1,1)), 0u);
+    // The reference is unjittered, but raster samples may move into the viewport by
+    // a pixel. Retain that fixed border without letting jitter change the tile grid.
+    let border = vec2f(1.0) + vec2f(2.0) / tessellation.resolution;
+    let planes = array<vec4f,4>(vec4f(1,0,0,border.x),vec4f(-1,0,0,border.x),vec4f(0,1,0,border.y),vec4f(0,-1,0,border.y));
+    for (var plane = 0u; plane < 4u; plane++) {
+        let sweep = dot(direction, planes[plane]);
+        let allowance = max((heights + vec3f(bounds.x)) * sweep, (heights + vec3f(bounds.y)) * sweep);
+        p = water_clip_polygon(p, water_plane_distances(a,b,c,planes[plane]) + allowance, 0u);
+    }
+    if (p.count < 3u) { return; }
+    var lo = vec2f(1e30); var hi = vec2f(-1e30);
+    for (var corner = 0u; corner < p.count; corner++) {
+        let q = a * p.points[corner].x + b * p.points[corner].y + c * p.points[corner].z;
+        let pixel = (q.xy / q.w * vec2f(0.5,-0.5) + vec2f(0.5)) * tessellation.resolution;
+        lo = min(lo, pixel); hi = max(hi, pixel);
+    }
+    let tile_pixels = pixels * ${WATER_TILE_CELLS}.0;
+    let origin = vec2i(floor(lo / tile_pixels));
+    let end = vec2i(ceil(hi / tile_pixels));
+    let size = vec2u(max(end - origin, vec2i(0)));
+    if (any(size == vec2u(0))) { return; }
+    var tile: WaterTile;
+    tile.meshlet = definition.index; tile.triangle = triangle; tile.body = definition.mesh;
+    tile.anchor = anchor; tile.origin = origin; tile.size = size; tile.pixels = pixels;
+    tiles[i] = tile;
+    counts.elements[i] = size.x * size.y;
+}
+`, [chunk_water_tessellation, chunk_read_meshlet_vertex_by_draw_index, chunk_scene_database_access,
+    WATER_BODIES_TABLE.chunk_read, WATER_WAVES_TABLE.chunk_read, chunk_folded_workgroup_index]) });

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

@@ -0,0 +1,6 @@
+export const WATER_WAVE_BATCH_STRUCT: WebGPUStruct;
+export const shader_water_wave_batch: ComputeShader;
+export const shader_water_wave_batch_finish: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_wave_batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_wave_batch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_wave_batch.js"],"names":[],"mappings":"AAYA,mDAC+E;AAO/E,oDA8CwH;AAMxH,2DAY4F;6BA/E/D,mCAAmC;8BALlC,+BAA+B"}

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

@@ -0,0 +1,85 @@
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { WATER_WAVES_TABLE as table } from "../medium/chunk_water_bodies.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_srdnoise2 } from "../../shader/chunk/noise/psrdnoise/chunk_srdnoise2.js";
+import { chunk_water_wave } from "./chunk_water_wave.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+
+export const WATER_WAVE_BATCH_STRUCT = WebGPUStruct.from({ resolution: u32, capacity: u32,
+    dt: f32, time: f32, damping: f32, apply_impulses: u32 }, 'WaterWaveBatch');
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('domain', WebGPUArray.u32)
+    .addStorageBuffer('state_current', WebGPUArray.from(f32))
+    .addStorageBuffer('state_previous', WebGPUArray.from(f32), true);
+export const shader_water_wave_batch = ComputeShader.from({ label: 'Water / batched wave step', 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 n = batch.resolution;
+    let row = i / (n * n);
+    if (row >= batch.capacity) { return; }
+    let params = ${table.marshalling_method_read}(&scene_database, row);
+    if (params.first_write != 0u || params.node == 0u || params.node == ~0u || domain[i] == 0u) { state_previous[i] = 0.0; return; }
+    if (batch.dt == 0.0) { return; }
+    let cell = vec2u(i % n, (i / n) % n);
+    let start = row * n * n;
+    let spacing = max((params.extent.zw - params.extent.xy) / f32(n - 1u), vec2f(1e-20));
+    let world = scene_read_node(&scene_database, params.node).global;
+    let scale = vec3f(length(world[0].xyz), length(world[1].xyz), length(world[2].xyz));
+    // A temporarily collapsed transform must not poison persistent histories with NaNs.
+    if (any(scale <= vec3f(1e-10))) { state_previous[i] = state_current[i]; return; }
+    let world_spacing = max(spacing * scale.xz, vec2f(1e-10));
+    let h = state_current[i];
+    let left = start + cell.y * n + select(cell.x - 1u, 0u, cell.x == 0u);
+    let right = start + cell.y * n + min(cell.x + 1u, n - 1u);
+    let down = start + select(cell.y - 1u, 0u, cell.y == 0u) * n + cell.x;
+    let up = start + min(cell.y + 1u, n - 1u) * n + cell.x;
+    let laplacian = (state_current[left] + state_current[right] - 2.0 * h) / (world_spacing.x * world_spacing.x)
+        + (state_current[down] + state_current[up] - 2.0 * h) / (world_spacing.y * world_spacing.y);
+    let position = mix(params.extent.xy, params.extent.zw, vec2f(cell) / f32(n - 1u));
+    let wind = params.forcing.xy * scale.xz;
+    let wind_direction = wind / max(length(wind), 1e-20);
+    let drift = wind_direction * params.forcing.w * batch.time;
+    var force = params.forcing.z / scale.y * srdnoise2((position * scale.xz - drift) / 6.0, 0.0).x;
+    if (batch.apply_impulses != 0u) {
+        for (var j = 0u; j < params.impulse_count; j++) {
+            let impulse = params.impulses[j];
+            let d = position - impulse.xy;
+            let world_delta = (world * vec4f(d.x, 0.0, d.y, 0.0)).xyz;
+            force += impulse.w / (batch.dt * scale.y) * exp(-dot(world_delta, world_delta) / max(impulse.z * impulse.z, 1e-6));
+        }
+    }
+    let damping = batch.damping + water_wave_sponge(cell, n, max(4.0, f32(n) * 0.04), 4.0);
+    // The authored surface has no bathymetry. The primitive producer uses a one-metre reference
+    // depth; the CFL cap follows both axes of its local grid. It does not define the mesh outline.
+    let celerity = 0.6 * min(world_spacing.x, world_spacing.y) / batch.dt;
+    state_previous[i] = water_wave_step(h, state_previous[i], laplacian,
+        water_wave_celerity2(1.0, celerity), damping, force, batch.dt);
+}
+`, [table.chunk_read, chunk_folded_workgroup_index, chunk_srdnoise2, chunk_water_wave, chunk_scene_database_access]) });
+
+const finish_resources = new ShaderResourceSetDescriptor();
+finish_resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32, true);
+const pg = table.page_iterator_symbol_prefix(64, true);
+export const shader_water_wave_batch_finish = ComputeShader.from({ label: 'Water / consume wave inputs', resources: finish_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(64)
+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; }
+    let row = ${pg}_slot_to_index(slot);
+    ${table.marshalling_method_write_field('first_write')}(&scene_database, row, 0u);
+    if (batch.apply_impulses != 0u) { ${table.marshalling_method_write_field('impulse_count')}(&scene_database, row, 0u); }
+}
+`, [table.chunk_iterate(64, true), table.wgsl_gen_write_field_code('first_write'),
+        table.wgsl_gen_write_field_code('impulse_count'), chunk_folded_workgroup_index]) });

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

@@ -0,0 +1,6 @@
+/** Bake the authored footprint once per new wave row, using the existing geometry BLAS. */
+export const shader_water_wave_domain: ComputeShader;
+/** Bilinear reconstruction cannot leave the extrema of its samples. Include the rest surface. */
+export const shader_water_wave_bounds: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_wave_domain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_wave_domain.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_wave_domain.js"],"names":[],"mappings":"AAwBA,2FAA2F;AAC3F,qDAqBsF;AAOtF,iGAAiG;AACjG,qDA4BmH;8BAlFrF,+BAA+B"}