@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -3,6 +3,7 @@ import { chunk_sample_volumetrics } from "../deferred/chunk_sample_volumetrics.j
 import { AVBOIT_OCCUPANCY_WORDS, AVBOIT_VOXEL_DOWNSCALE } from "../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
 import { AVBOIT_WARP_STRUCT } from "../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
 import { AVBOIT_DRAW_TARGETS } from "../rasterize/native/avboit/avboit_draw_fragment_body.js";
+import { chunk_avboit_footprint_bias } from "../rasterize/native/avboit/chunk_avboit_footprint_bias.js";
 import { chunk_avboit_occupancy_mark } from "../rasterize/native/avboit/chunk_avboit_occupancy_mark.js";
 import { chunk_avboit_rgb_contribution } from "../rasterize/native/avboit/chunk_avboit_rgb_contribution.js";
 import { chunk_avboit_sample_transmittance } from "../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
@@ -10,8 +11,11 @@ import { chunk_avboit_splat_slice } from "../rasterize/native/avboit/chunk_avboi
 import { chunk_avboit_split_counts } from "../rasterize/native/avboit/chunk_avboit_split_counts.js";
 import { chunk_avboit_transmittance_to_extinction } from "../rasterize/native/avboit/chunk_avboit_transmittance_to_extinction.js";
 import { chunk_avboit_view_depth_to_physical } from "../rasterize/native/avboit/chunk_avboit_view_depth_to_physical.js";
+import { chunk_avboit_view_depth_to_virtual } from "../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
 import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/shader_avboit_occupancy.js";
 import { chunk_get_view_space_depth } from "../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_is_background } from "../shader/chunk/depth/chunk_is_background.js";
+import { chunk_is_on_screen_i32 } from "../shader/chunk/texture/chunk_is_on_screen_i32.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ImageShader } from "../shader/ImageShader.js";
@@ -121,18 +125,22 @@ struct WaterContribution {
 fn main(@builtin(position) coord: vec4f) -> WaterContribution {
     let pixel = vec2u(coord.xy);
     let d = textureLoad(interface_depth, pixel, 0).r;
-    if (d <= 0.0) { discard; }
     let z = get_view_space_depth(d, camera);
+    // the water splats into the volume too, and a plane seen at an angle runs through depth across a
+    // voxel (avboit_footprint_bias). Taken before the discard, in uniform control flow; a dry pixel's
+    // virtual coordinate clamps, so the derivative at the shore stays finite and the cap holds it
+    let footprint = avboit_footprint_bias(&warp, fwidth(avboit_view_depth_to_virtual(&warp, z)));
+    if (d <= 0.0) { discard; }
     let uv = coord.xy / vec2f(textureDimensions(interface_depth, 0));
-    let front = avboit_sample_transmittance(&warp, tIntegral, sLinear, uv, z);
+    let front = avboit_sample_transmittance(&warp, tIntegral, sLinear, uv, z, footprint);
     let t = textureLoad(transmission, pixel, 0).rgb;
     let w = textureLoad(radiance, pixel, 0).rgb;
     let fog = sample_volumetrics(z, uv, coord.xy);
     let c = avboit_rgb_contribution(w, t, front, fog);
     return WaterContribution(c.color, c.norm, c.extinction, c.emission);
 }
-`, [chunk_get_view_space_depth, chunk_avboit_sample_transmittance,
-            chunk_avboit_rgb_contribution, chunk_sample_volumetrics]),
+`, [chunk_get_view_space_depth, chunk_avboit_view_depth_to_virtual, chunk_avboit_footprint_bias,
+            chunk_avboit_sample_transmittance, chunk_avboit_rgb_contribution, chunk_sample_volumetrics]),
     }), targets: AVBOIT_DRAW_TARGETS,
 });
 
@@ -157,13 +165,13 @@ fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
                 let t = textureLoad(trace_metadata, pixel, 0);
                 // Only actual geometry/sky boundaries seed the spatial fade. Trace budget
                 // or numerical failures must not create moving 64-pixel holes around themselves.
-                if (t.b <= 0.0 || textureLoad(scene_depth, pixel, 0).r == 0.0) { distance = 0.0; }
+                if (t.b <= 0.0 || is_background(textureLoad(scene_depth, pixel, 0).r)) { distance = 0.0; }
             }
         }
     }
     return vec4f(distance, 0.0, 0.0, 1.0);
 }
-`),
+`, [chunk_is_background]),
     }), targets: [{ format: "r16float" }],
 });
 
@@ -180,14 +188,14 @@ fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
     var distance = 16.0;
     for (var offset = -16; offset <= 16; offset++) {
         let sample = pixel + ${vertical ? "vec2i(0, offset)" : "vec2i(offset, 0)"};
-        if (all(sample >= vec2i(0)) && all(sample < size)) {
+        if (is_on_screen_i32(sample, size)) {
             let d = textureLoad(distance_field, sample, 0).r;
             distance = min(distance, ${vertical ? "length(vec2f(d, f32(offset)))" : "d + abs(f32(offset))"});
         }
     }
     return vec4f(distance, 0.0, 0.0, 1.0);
 }
-`),
+`, [chunk_is_on_screen_i32]),
     }), targets: [{ format: "r16float" }] });
 }
 export const shader_water_confidence_x = confidence_distance_shader(false);
@@ -246,7 +254,9 @@ fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
         }
         case 8u, 9u: {
             let z = get_view_space_depth(textureLoad(interface_depth, pixel, 0).r, camera);
-            let front = avboit_sample_transmittance(&warp, tIntegral, sLinear, uv, z);
+            // without the draw's footprint (a derivative this switch cannot take): where the water is
+            // seen at an angle this also shows it occluding itself, which the draw looks past
+            let front = avboit_sample_transmittance(&warp, tIntegral, sLinear, uv, z, 0.0);
             color = select(front, (1.0 - t.rgb) * front, inspection.mode == 9u);
         }
         default: {}

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

@@ -0,0 +1,25 @@
+/**
+ * A shared wave atlas, indexed by occupied water_waves rows. Calm bodies allocate no grid.
+ * Each fixed step dispatches the whole atlas once; tessellated vertices sample it in local xz.
+ * The regular grid is a displacement field, never the rendered water footprint.
+ */
+export class GPUWaterWaveSimulation {
+    onInputsConsumed: Signal;
+    resolution: number;
+    step: number;
+    max_steps_per_frame: number;
+    damping: number;
+    get time(): number;
+    get buffer(): any;
+    get grid_resolution(): number;
+    advance(dt: any): void;
+    dispose(): void;
+    record({ graph, device, scene }: {
+        graph: any;
+        device: any;
+        scene: any;
+    }): void;
+    #private;
+}
+import Signal from "../../../../core/events/signal/Signal.js";
+//# sourceMappingURL=GPUWaterWaveSimulation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GPUWaterWaveSimulation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterWaveSimulation.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACI,yBAAgC;IAChC,mBAAiB;IACjB,aAAe;IACf,4BAAwB;IACxB,gBAAe;IAYf,mBAAiC;IACjC,kBAAkD;IAClD,8BAAqE;IAErE,uBAIC;IAED,gBAMC;IAED;;;;aAiFC;;CACJ;mBA/HkB,0CAA0C"}

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

@@ -0,0 +1,128 @@
+import Signal from "../../../../core/events/signal/Signal.js";
+import { assert } from "../../../../core/assert.js";
+import { WATER_WAVE_BATCH_STRUCT, shader_water_wave_batch, shader_water_wave_batch_finish } from "./shader_water_wave_batch.js";
+import { shader_water_wave_bounds, shader_water_wave_domain } from "./shader_water_wave_domain.js";
+
+/**
+ * A shared wave atlas, indexed by occupied water_waves rows. Calm bodies allocate no grid.
+ * Each fixed step dispatches the whole atlas once; tessellated vertices sample it in local xz.
+ * The regular grid is a displacement field, never the rendered water footprint.
+ */
+export class GPUWaterWaveSimulation {
+    onInputsConsumed = new Signal();
+    resolution = 128;
+    step = 1 / 120;
+    max_steps_per_frame = 8;
+    damping = 0.08;
+    #device = null;
+    #scene = null;
+    #state = [];
+    #domain = null;
+    #capacity = 0;
+    #resolution = 0;
+    #parity = 0;
+    #pending = 0;
+    #time = 0;
+    #recorded = new WeakSet();
+    #write_pending = true;
+    get time() { return this.#time; }
+    get buffer() { return this.#state[this.#parity]; }
+    get grid_resolution() { return this.#resolution || this.resolution; }
+
+    advance(dt) {
+        assert.isFinite(dt, 'dt'); assert.greaterThanOrEqual(dt, 0, 'dt');
+        this.#pending += dt;
+        this.#write_pending = true;
+    }
+
+    dispose() {
+        for (const buffer of this.#state) { buffer.destroy(); }
+        this.#domain?.destroy(); this.#domain = null;
+        this.#state = []; this.#capacity = 0; this.#device = null; this.#scene = null;
+        this.#recorded = new WeakSet();
+        this.#write_pending = true;
+    }
+
+    record({ graph, device, scene }) {
+        if (this.#recorded.has(graph)) { return; }
+        if (device !== this.#device || scene !== this.#scene) {
+            this.dispose(); this.#device = device; this.#scene = scene;
+        }
+        this.#recorded.add(graph);
+        if (!this.#write_pending) { return; }
+        this.#write_pending = false;
+        const table = scene.scene_database.get('water_waves');
+        const capacity = table.count === 0 ? 0 : table.element_capacity;
+        assert.isInteger(this.resolution, 'resolution'); assert.greaterThanOrEqual(this.resolution, 2, 'resolution');
+        assert.greaterThan(this.step, 0, 'step');
+        const resize = capacity > this.#capacity || (capacity === 0 && this.#capacity !== 0) || this.resolution !== this.#resolution;
+        const old = this.#state;
+        const old_domain = this.#domain;
+        if (resize || old.length === 0) {
+            const size = Math.max(4, capacity * this.resolution ** 2 * 4);
+            assert.lessThanOrEqual(size, device.limits.maxStorageBufferBindingSize, 'Water wave atlas exceeds device storage limit; lower waves.resolution');
+            this.#state = [0, 1].map(i => device.createBuffer({ label: `Water / wave state ${i}`, size,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST }));
+            this.#domain = device.createBuffer({ label: 'Water / authored footprint', size,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST });
+            this.#capacity = capacity;
+        }
+        const same_resolution = this.#resolution === this.resolution;
+        this.#resolution = this.resolution;
+        const steps = Math.min(Math.floor(this.#pending / this.step + 1e-6), this.max_steps_per_frame);
+        this.#pending = Math.max(0, Math.min(this.#pending - steps * this.step, this.step));
+        const start = this.#parity, time = this.#time, state = this.#state, domain = this.#domain;
+        this.#parity = (start + steps) % 2;
+        this.#time += steps * this.step;
+        const n = this.#resolution, dt = this.step, damping = this.damping;
+        const pass = graph.add('Water / batched surface update', {}, (_d, _r, { encoder }) => {
+            if (state !== old) {
+                if (same_resolution && old.length !== 0) {
+                    for (let i = 0; i < 2; i++) { encoder.copyBufferToBuffer(old[i], 0, state[i], 0, Math.min(old[i].size, state[i].size)); }
+                    encoder.copyBufferToBuffer(old_domain, 0, domain, 0, Math.min(old_domain.size, domain.size));
+                }
+                encoder.done.then(() => { for (const buffer of old) { buffer.destroy(); } old_domain?.destroy(); });
+            }
+            if (capacity === 0) { return; }
+            const groups = Math.ceil(capacity * n * n / 128);
+            shader_water_wave_domain.dispatch({ encoder, bindings: {
+                batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT,
+                    { resolution: n, capacity, apply_impulses: same_resolution ? 0 : 1 }),
+                scene_database: scene.scene_database_buffer, domain,
+                geometries: scene.geometries.buffer_metadata,
+                blas_lookup: scene.geometries.blas.buffer_metadata, blas_data: scene.geometries.blas.buffer_data,
+                meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data,
+            }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+            const dispatch = (parity, step_dt, step_time, apply_impulses) => {
+                shader_water_wave_batch.dispatch({ encoder, bindings: {
+                    batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT,
+                        { resolution: n, capacity, dt: step_dt, time: step_time, damping, apply_impulses }),
+                    scene_database: scene.scene_database_buffer, domain, state_current: state[parity], state_previous: state[1 - parity],
+                }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+            };
+            // Clear both histories of new/reused slots before advancing, then release the reset flag.
+            dispatch(0, 0, time, 0); dispatch(1, 0, time, 0);
+            const finish = apply_impulses => {
+                const groups = table.dispatch_group_count(64);
+                shader_water_wave_batch_finish.dispatch({ encoder, bindings: { scene_database: scene.scene_database_buffer,
+                    batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT,
+                        { resolution: n, capacity, dt, time, damping, apply_impulses }) },
+                    group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+            };
+            finish(0);
+            for (let i = 0; i < steps; i++) { dispatch((start + i) % 2, dt, time + i * dt, i === 0 ? 1 : 0); }
+            if (steps > 0) {
+                finish(1);
+                // Submit is the ownership boundary for staged CPU inputs. Use the encoder's
+                // existing synchronous signal so a later scene/update cannot be cleared by
+                // an old promise callback.
+                encoder.onFinished.addOne(() => this.onInputsConsumed.dispatch(scene));
+            }
+            shader_water_wave_bounds.dispatch({ encoder, bindings: {
+                batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT, { resolution: n, capacity }),
+                scene_database: scene.scene_database_buffer, state: state[(start + steps) % 2],
+            }, group_count_x: Math.min(capacity, 65535), group_count_y: Math.ceil(capacity / 65535) });
+        });
+        pass.make_side_effect();
+    }
+}

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

@@ -0,0 +1,6 @@
+/** 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;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=WATER_WAVE_RECORD_STRUCT.d.ts.map

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

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

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

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

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