@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/libraries/water/src/buoyancy.js

@@ -0,0 +1,80 @@
+// ============================================================================
+// Buoyancy System — applies water height-based forces to ships/entities
+// Originally based on to-the-ocean's buoyancy implementation
+// ============================================================================
+const GRAVITY = 9.8;
+const WATER_DENSITY = 1000;
+const BUOYANCY_SPRING = 20;
+const BUOYANCY_DAMPING = 8;
+const ANGULAR_DAMPING = 3;
+const MAX_TILT = 0.5;
+const SHIP_HALF_LENGTH = 4;
+const SHIP_HALF_WIDTH = 2;
+export class BuoyancySystem {
+    physics;
+    constructor(physics) {
+        this.physics = physics;
+    }
+    applyBuoyancy(ent, dt) {
+        // Sample water height at bow, stern, port, starboard
+        const cosH = Math.cos(ent.heading);
+        const sinH = Math.sin(ent.heading);
+        const bowX = ent.x + sinH * SHIP_HALF_LENGTH;
+        const bowZ = ent.z + cosH * SHIP_HALF_LENGTH;
+        const sternX = ent.x - sinH * SHIP_HALF_LENGTH;
+        const sternZ = ent.z - cosH * SHIP_HALF_LENGTH;
+        const portX = ent.x - cosH * SHIP_HALF_WIDTH;
+        const portZ = ent.z + sinH * SHIP_HALF_WIDTH;
+        const starX = ent.x + cosH * SHIP_HALF_WIDTH;
+        const starZ = ent.z - sinH * SHIP_HALF_WIDTH;
+        const whBow = this.physics.sampleWaterAt(bowX, bowZ);
+        const whStern = this.physics.sampleWaterAt(sternX, sternZ);
+        const whPort = this.physics.sampleWaterAt(portX, portZ);
+        const whStar = this.physics.sampleWaterAt(starX, starZ);
+        const avgWaterHeight = (whBow + whStern + whPort + whStar) / 4;
+        // Vertical buoyancy: spring toward water surface
+        const dy = avgWaterHeight - ent.y;
+        ent.vy += dy * BUOYANCY_SPRING * dt;
+        ent.vy *= Math.max(0, 1 - BUOYANCY_DAMPING * dt);
+        // Pitch from bow vs stern differential
+        const pitchForce = (whStern - whBow) / (SHIP_HALF_LENGTH * 2);
+        // Roll from port vs starboard differential
+        const rollForce = (whStar - whPort) / (SHIP_HALF_WIDTH * 2);
+        ent.angularVelX += pitchForce * 5 * dt;
+        ent.angularVelZ += rollForce * 5 * dt;
+        ent.angularVelX *= Math.max(0, 1 - ANGULAR_DAMPING * dt);
+        ent.angularVelZ *= Math.max(0, 1 - ANGULAR_DAMPING * dt);
+        let newPitch = ent.pitch + ent.angularVelX * dt;
+        let newRoll = ent.roll + ent.angularVelZ * dt;
+        if (newPitch > MAX_TILT) {
+            newPitch = MAX_TILT;
+            ent.angularVelX = 0;
+        }
+        else if (newPitch < -MAX_TILT) {
+            newPitch = -MAX_TILT;
+            ent.angularVelX = 0;
+        }
+        if (newRoll > MAX_TILT) {
+            newRoll = MAX_TILT;
+            ent.angularVelZ = 0;
+        }
+        else if (newRoll < -MAX_TILT) {
+            newRoll = -MAX_TILT;
+            ent.angularVelZ = 0;
+        }
+        ent.pitch = newPitch;
+        ent.roll = newRoll;
+        // Apply gravity
+        ent.vy -= GRAVITY * dt;
+        // Integrate position
+        ent.y += ent.vy * dt;
+        // Clamp to prevent falling through
+        if (ent.y < avgWaterHeight - 5) {
+            ent.y = avgWaterHeight - 5;
+            ent.vy = Math.max(0, ent.vy);
+        }
+    }
+    sampleWaterAt(x, z) {
+        return this.physics.sampleWaterAt(x, z);
+    }
+}

package/dist/libraries/water/src/index.js

@@ -0,0 +1,12 @@
+// Re-export low-poly water physics system
+export { BuoyancySystem } from "./buoyancy.js";
+export { shoreDamping, shoreDisplacement, waterCutout } from "./shore-damping.js";
+export { WATER_BUFFER_BYTES, WATER_FLOW_OFFSET, WATER_GRID, WATER_HEIGHT_OFFSET, WATER_NORMAL_OFFSET, WaterBuffer } from "./water-buffer.js";
+export { CHUNK_GRID, CHUNK_OVERLAP, CHUNK_SIZE, CHUNK_WORLD_SIZE, MAX_CHUNKS } from "./water-chunks.js";
+export { DEFAULT_PHYSICS_CONFIG, WaterPhysics } from "./water-physics.js";
+export { DEFAULT_RENDER_CONFIG, WaterRenderer } from "./water-renderer.js";
+export { collectShoreSources, collectWakeSources, MAX_SHORES, MAX_WAKES, packShoreSources, SHORE_FLOATS, WAKE_FLOATS } from "./wave-sources.js";
+// Water SAB Channel (defineChannel-based SharedArrayBuffer protocol)
+export { WATER_FLOW_OFFSET_SAB, WATER_GRID_SAB, WATER_HDR_SAB, WATER_HEIGHT_OFFSET_SAB, WATER_MAGIC_SAB, WATER_NORMAL_OFFSET_SAB, WATER_VERSION_SAB, WaterBufferReader, WaterBufferWriter, WaterChannel } from "./water-sab.js";
+// Declarative library descriptor
+export { WaterLib, WaterReaderTok, WaterWriterTok } from "./library.js";

package/dist/libraries/water/src/library.js

@@ -0,0 +1,65 @@
+// ============================================================================
+// WaterLib — declarative engine library descriptor for @downdraft/engine/libraries/water
+//
+// Games declare `libraries: [WaterLib]` (or `[[WaterLib, { patchSize: 8 }]]`
+// to override config) in their GameModule. The host allocates the water SAB,
+// creates the WaterBufferWriter (sim-side) and WaterBufferReader (renderer-side),
+// and exposes them via typed tokens.
+//
+// Games that need full control can still import WaterBufferWriter/Reader
+// directly (escape hatch).
+// ============================================================================
+import { resourceToken } from "@downdraft/engine";
+import { WaterBufferReader, WaterBufferWriter, WaterChannel } from "./water-sab.js";
+// ── Typed tokens (DI) ──
+/** Token for the sim-side water buffer writer. Inject in sim systems. */
+export const WaterWriterTok = resourceToken("water:writer");
+/** Token for the renderer-side water buffer reader. Inject in renderer passes. */
+export const WaterReaderTok = resourceToken("water:reader");
+// ── Descriptor ──
+export const WaterLib = {
+    name: "water",
+    version: "1.0.0",
+    sabChannels: [
+        { name: "water", size: WaterChannel.allocate().byteLength },
+    ],
+    provides: [WaterWriterTok, WaterReaderTok],
+    sim: {
+        create(config, ctx) {
+            const writer = new WaterBufferWriter(ctx.buffers.water);
+            writer.init(config.patchSize ?? 4);
+            ctx.provide(WaterWriterTok, writer);
+            return writer;
+        },
+        dispose(_writer) {
+            // WaterBufferWriter holds only a SAB view — no GPU resources to free.
+            // The SAB itself is managed by the host.
+        },
+        // tick is game-specific (calls updateWaterBuffer with Gerstner waves,
+        // shore damping, wake sources, etc.) — games wire this via onReady.
+    },
+    tickPhase: "pre-physics",
+    renderer: {
+        init(_config, _ctx) {
+            // WaterPass is in @downdraft/engine, not this library.
+            // The game creates the pass in onReady and injects WaterReaderTok.
+            return null;
+        },
+        setBuffers(_instance, buffers, _ctx) {
+            // The reader is created here and provided to the DI graph.
+            // Games inject WaterReaderTok in onReady to get it.
+            const reader = new WaterBufferReader(buffers.water);
+            if (_ctx?.provide) {
+                _ctx.provide(WaterReaderTok, reader);
+            }
+            return reader;
+        },
+        dispose(_instance) {
+            // WaterBufferReader holds only a SAB view — no GPU resources to free.
+        },
+    },
+    defaultConfig: {
+        patchSize: 4,
+        gridSize: 256,
+    },
+};

package/dist/libraries/water/src/shore-damping.js

@@ -0,0 +1,70 @@
+// ============================================================================
+// Shore Damping — shared utility for flattening water near terrain regions
+// Returns 0.0 inside terrain (flat water), 1.0 far from shore (full waves).
+// Also provides shoreDisplacement — ring waves traveling inward toward shore.
+// ============================================================================
+function smoothstep(edge0, edge1, x) {
+    const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+    return t * t * (3 - 2 * t);
+}
+export function shoreDamping(x, z, sources, count) {
+    let damping = 1.0;
+    for (let i = 0; i < count; i++) {
+        const src = sources[i];
+        const r = src.radius;
+        if (r < 0.001)
+            continue;
+        const dx = x - src.x;
+        const dz = z - src.z;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        const flatR = r * 1.0;
+        const dampR = r * 1.2 + 8.0;
+        const t = smoothstep(flatR, dampR, dist);
+        if (t < damping)
+            damping = t;
+    }
+    return damping;
+}
+export function shoreDisplacement(x, z, time, sources, count) {
+    let totalH = 0.0;
+    for (let i = 0; i < count; i++) {
+        const src = sources[i];
+        const r = src.radius;
+        if (r < 0.001)
+            continue;
+        const dx = x - src.x;
+        const dz = z - src.z;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        const flatR = r * 1.0;
+        const dampR = r * 1.2 + 8.0;
+        const rampUp = smoothstep(flatR, dampR, dist);
+        if (rampUp < 0.001)
+            continue;
+        const bandEnd = dampR + 20.0;
+        const fadeW = 8.0;
+        const outerFade = 1.0 - smoothstep(bandEnd - fadeW, bandEnd, dist);
+        if (outerFade < 0.001)
+            continue;
+        const ringDist = dist - r;
+        const k = 0.2;
+        const shoal = 1.0 - rampUp * 0.6;
+        const waveAmp = 0.5 * shoal;
+        const ringH = Math.sin(ringDist * k + time * 0.35) * waveAmp;
+        const distFade = Math.exp(-Math.max(ringDist - (dampR - r), 0.0) * 0.08);
+        totalH += ringH * distFade * outerFade;
+    }
+    return totalH;
+}
+export function waterCutout(x, z, sources, count) {
+    for (let i = 0; i < count; i++) {
+        const src = sources[i];
+        if (src.cutoutRadius < 0.001)
+            continue;
+        const dx = x - src.x;
+        const dz = z - src.z;
+        const dist = Math.sqrt(dx * dx + dz * dz);
+        if (dist < src.cutoutRadius)
+            return true;
+    }
+    return false;
+}

package/dist/libraries/water/src/water-buffer.js

@@ -0,0 +1,78 @@
+// ============================================================================
+// Water Buffer — 256×256 heightfield grid for water physics + rendering sync
+// Water buffer definitions
+// ============================================================================
+export const WATER_GRID = 256;
+export const WATER_HEIGHT_OFFSET = 64; // 16 u32 header
+export const WATER_NORMAL_OFFSET = WATER_HEIGHT_OFFSET + WATER_GRID * WATER_GRID * 4;
+export const WATER_FLOW_OFFSET = WATER_NORMAL_OFFSET + WATER_GRID * WATER_GRID * 12;
+export const WATER_BUFFER_BYTES = WATER_FLOW_OFFSET + WATER_GRID * WATER_GRID * 8;
+const WATER_HDR = {
+    GRID_SIZE: 2,
+    PATCH_SIZE: 3,
+    ORIGIN_X: 5,
+    ORIGIN_Z: 6,
+};
+export class WaterBuffer {
+    buffer;
+    u32;
+    i32;
+    heights;
+    normals;
+    flow;
+    patchSize;
+    originX = 0;
+    originZ = 0;
+    constructor(patchSize = 4) {
+        this.buffer = new ArrayBuffer(WATER_BUFFER_BYTES);
+        this.u32 = new Uint32Array(this.buffer);
+        this.i32 = new Int32Array(this.buffer);
+        this.heights = new Float32Array(this.buffer, WATER_HEIGHT_OFFSET, WATER_GRID * WATER_GRID);
+        this.normals = new Float32Array(this.buffer, WATER_NORMAL_OFFSET, WATER_GRID * WATER_GRID * 3);
+        this.flow = new Float32Array(this.buffer, WATER_FLOW_OFFSET, WATER_GRID * WATER_GRID * 2);
+        this.patchSize = patchSize;
+        this.u32[WATER_HDR.GRID_SIZE] = WATER_GRID;
+        this.u32[WATER_HDR.PATCH_SIZE] = patchSize;
+    }
+    getGridSize() { return WATER_GRID; }
+    getPatchSize() { return this.patchSize; }
+    getOrigin() { return { x: this.originX, z: this.originZ }; }
+    setOrigin(x, z) {
+        this.originX = x;
+        this.originZ = z;
+        this.i32[WATER_HDR.ORIGIN_X] = x;
+        this.i32[WATER_HDR.ORIGIN_Z] = z;
+    }
+    setHeight(gx, gz, h) {
+        this.heights[gz * WATER_GRID + gx] = h;
+    }
+    getHeight(gx, gz) {
+        return this.heights[gz * WATER_GRID + gx];
+    }
+    sampleHeight(gx, gz) {
+        const x0 = Math.floor(gx);
+        const z0 = Math.floor(gz);
+        const x1 = Math.min(x0 + 1, WATER_GRID - 1);
+        const z1 = Math.min(z0 + 1, WATER_GRID - 1);
+        const fx = gx - x0;
+        const fz = gz - z0;
+        const h00 = this.heights[z0 * WATER_GRID + x0];
+        const h10 = this.heights[z0 * WATER_GRID + x1];
+        const h01 = this.heights[z1 * WATER_GRID + x0];
+        const h11 = this.heights[z1 * WATER_GRID + x1];
+        const h0 = h00 * (1 - fx) + h10 * fx;
+        const h1 = h01 * (1 - fx) + h11 * fx;
+        return h0 * (1 - fz) + h1 * fz;
+    }
+    sampleWorldHeight(worldX, worldZ) {
+        const gx = ((worldX - this.originX) / this.patchSize % WATER_GRID + WATER_GRID) % WATER_GRID;
+        const gz = ((worldZ - this.originZ) / this.patchSize % WATER_GRID + WATER_GRID) % WATER_GRID;
+        return this.sampleHeight(gx, gz);
+    }
+    getHeightsRef() {
+        return this.heights;
+    }
+    getBuffer() {
+        return this.buffer;
+    }
+}

package/dist/libraries/water/src/water-chunks.js

@@ -0,0 +1,5 @@
+export const CHUNK_SIZE = 64;
+export const CHUNK_OVERLAP = 2;
+export const CHUNK_GRID = CHUNK_SIZE + 2 * CHUNK_OVERLAP; // 68
+export const MAX_CHUNKS = 25;
+export const CHUNK_WORLD_SIZE = CHUNK_SIZE * 4; // 256m at 4m patch

package/dist/libraries/water/src/water-physics.js

@@ -0,0 +1,315 @@
+// ============================================================================
+// Water Physics — updates the 256×256 heightfield grid each tick
+// Combines Gerstner waves + wind chop + shore damping + shore ring waves
+// Water physics simulation
+// ============================================================================
+import { shoreDamping, shoreDisplacement, waterCutout } from "./shore-damping.js";
+import { CHUNK_GRID, CHUNK_OVERLAP, CHUNK_WORLD_SIZE, MAX_CHUNKS } from "./water-chunks.js";
+import { MAX_WAKES } from "./wave-sources.js";
+export const DEFAULT_PHYSICS_CONFIG = {
+    waves: [
+        { direction: [1, 0], amplitude: 0.5, wavelength: 10, speed: 1.0, steepness: 0.75 },
+        { direction: [0.7, 0.7], amplitude: 0.25, wavelength: 5, speed: 1.2, steepness: 0.6 },
+        { direction: [-0.5, 0.8], amplitude: 0.15, wavelength: 3, speed: 1.5, steepness: 0.5 },
+        { direction: [0.3, -0.9], amplitude: 0.08, wavelength: 1.5, speed: 2.0, steepness: 0.4 },
+    ],
+    windSpeed: 3,
+    windDirX: 1,
+    windDirZ: 0,
+    waterLevel: 0,
+    waterRenderDistance: 500, // 500m radius around player
+};
+function windChopAmp(windSpeed) {
+    const ss = Math.max(0, Math.min(1, (windSpeed - 2) / 23));
+    return 0.15 + ss * 0.65;
+}
+export class WaterPhysics {
+    buffer;
+    config;
+    time = 0;
+    shoreSources = [];
+    shoreCount = 0;
+    wakeSources = [];
+    wakeCount = 0;
+    precomputedWaves = [];
+    gerstnerPhase;
+    shoreBandEndSq;
+    shoreCutoutRSq;
+    shoreDampR;
+    shoreDampRange;
+    chunks = new Map();
+    activeChunks = [];
+    constructor(buffer, config) {
+        this.buffer = buffer;
+        this.config = { ...DEFAULT_PHYSICS_CONFIG, ...config };
+        this.precomputeWaves();
+        for (let i = 0; i < 128; i++) {
+            this.shoreSources.push({ x: 0, z: 0, radius: 0, cutoutRadius: 0 });
+        }
+        for (let i = 0; i < MAX_WAKES; i++) {
+            this.wakeSources.push({ x: 0, z: 0, dirX: 0, dirZ: 0, speed: 0 });
+        }
+        this.gerstnerPhase = new Float64Array(8);
+        this.shoreBandEndSq = new Float64Array(128);
+        this.shoreCutoutRSq = new Float64Array(128);
+        this.shoreDampR = new Float64Array(128);
+        this.shoreDampRange = new Float64Array(128);
+    }
+    precomputeWaves() {
+        this.precomputedWaves = this.config.waves.map(w => {
+            const k = (2 * Math.PI) / w.wavelength;
+            const dirLen = Math.sqrt(w.direction[0] ** 2 + w.direction[1] ** 2);
+            return {
+                k,
+                dx: dirLen > 0 ? w.direction[0] / dirLen : 1,
+                dz: dirLen > 0 ? w.direction[1] / dirLen : 0,
+                amplitude: w.amplitude,
+                speedFactor: w.speed * 2 * Math.PI,
+            };
+        });
+    }
+    getConfig() { return this.config; }
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+        this.precomputeWaves();
+    }
+    getBuffer() { return this.buffer; }
+    setShoreSources(sources, count) {
+        this.shoreSources = sources;
+        this.shoreCount = count;
+    }
+    setWakeSources(sources, count) {
+        this.wakeSources = sources;
+        this.wakeCount = count;
+    }
+    weatherWaveScale() {
+        // Scale Gerstner amplitudes by wind speed: calm=0.3x, moderate=0.6x, storm=2.5x
+        const ws = this.config.windSpeed;
+        return 0.3 + Math.max(0, ws - 2) * 0.1;
+    }
+    update(dt, playerX, playerZ) {
+        this.time += dt;
+        const patchSize = this.buffer.getPatchSize();
+        const renderDist = this.config.waterRenderDistance;
+        const renderDistSq = renderDist * renderDist;
+        // Precompute wave phases and shore data
+        const chopAmp = windChopAmp(this.config.windSpeed);
+        const waveScale = this.weatherWaveScale();
+        const t = this.time;
+        const waves = this.precomputedWaves;
+        const numWaves = waves.length;
+        const shoreSrcs = this.shoreSources;
+        const shoreCnt = this.shoreCount;
+        const wakeSrcs = this.wakeSources;
+        const wakeCnt = this.wakeCount;
+        for (let i = 0; i < numWaves; i++) {
+            this.gerstnerPhase[i] = waves[i].speedFactor * t;
+        }
+        for (let i = 0; i < shoreCnt; i++) {
+            const src = shoreSrcs[i];
+            const r = src.radius;
+            const dampR = r * 1.2 + 8.0;
+            this.shoreDampR[i] = dampR;
+            this.shoreDampRange[i] = dampR - r;
+            this.shoreBandEndSq[i] = (dampR + 20.0) * (dampR + 20.0);
+            this.shoreCutoutRSq[i] = src.cutoutRadius * src.cutoutRadius;
+        }
+        const chopT1a = t * 0.12, chopT1b = t * 0.10;
+        const chopT2a = t * 0.2, chopT2b = t * 0.15;
+        const chopT3 = t * 0.08;
+        const shoreTime = t * 0.35;
+        // Determine which chunks should be active (fixed positions, loaded in circle around player)
+        const playerChunkX = Math.floor(playerX / CHUNK_WORLD_SIZE);
+        const playerChunkZ = Math.floor(playerZ / CHUNK_WORLD_SIZE);
+        const chunksPerSide = Math.ceil(renderDist / CHUNK_WORLD_SIZE) + 1;
+        const newActive = [];
+        const seenKeys = new Set();
+        for (let cz = playerChunkZ - chunksPerSide; cz <= playerChunkZ + chunksPerSide; cz++) {
+            for (let cx = playerChunkX - chunksPerSide; cx <= playerChunkX + chunksPerSide; cx++) {
+                // Check if chunk center is within render distance (plus chunk radius for overlap)
+                const chunkCenterX = cx * CHUNK_WORLD_SIZE + CHUNK_WORLD_SIZE / 2;
+                const chunkCenterZ = cz * CHUNK_WORLD_SIZE + CHUNK_WORLD_SIZE / 2;
+                const ddx = chunkCenterX - playerX;
+                const ddz = chunkCenterZ - playerZ;
+                const chunkRadius = CHUNK_WORLD_SIZE * 0.75;
+                if (ddx * ddx + ddz * ddz > (renderDist + chunkRadius) * (renderDist + chunkRadius))
+                    continue;
+                if (newActive.length >= MAX_CHUNKS)
+                    continue;
+                const key = cx + "," + cz;
+                seenKeys.add(key);
+                let chunk = this.chunks.get(key);
+                if (!chunk) {
+                    chunk = {
+                        chunkX: cx,
+                        chunkZ: cz,
+                        originX: cx * CHUNK_WORLD_SIZE - CHUNK_OVERLAP * patchSize,
+                        originZ: cz * CHUNK_WORLD_SIZE - CHUNK_OVERLAP * patchSize,
+                        heights: new Float32Array(CHUNK_GRID * CHUNK_GRID),
+                    };
+                    this.chunks.set(key, chunk);
+                }
+                newActive.push(chunk);
+            }
+        }
+        // Remove inactive chunks
+        for (const [key] of this.chunks.entries()) {
+            if (!seenKeys.has(key))
+                this.chunks.delete(key);
+        }
+        this.activeChunks = newActive;
+        // Compute heights for each active chunk
+        newActive.forEach((chunk) => {
+            this.computeChunkHeights(chunk, playerX, playerZ, renderDistSq, patchSize, {
+                chopAmp, waveScale, t, waves, numWaves, shoreSrcs, shoreCnt, wakeSrcs, wakeCnt,
+                chopT1a, chopT1b, chopT2a, chopT2b, chopT3, shoreTime,
+            });
+        });
+    }
+    computeChunkHeights(chunk, playerX, playerZ, renderDistSq, patchSize, ctx) {
+        const heights = chunk.heights;
+        const originX = chunk.originX;
+        const originZ = chunk.originZ;
+        for (let gz = 0; gz < CHUNK_GRID; gz++) {
+            const worldZ = originZ + gz * patchSize;
+            const rowOffset = gz * CHUNK_GRID;
+            for (let gx = 0; gx < CHUNK_GRID; gx++) {
+                const worldX = originX + gx * patchSize;
+                // Skip cells outside render distance (circular mask around player)
+                const ddx = worldX - playerX;
+                const ddz = worldZ - playerZ;
+                if (ddx * ddx + ddz * ddz > renderDistSq) {
+                    heights[rowOffset + gx] = -1000;
+                    continue;
+                }
+                let h = 0;
+                for (let i = 0; i < ctx.numWaves; i++) {
+                    const w = ctx.waves[i];
+                    h += w.amplitude * ctx.waveScale * Math.sin(w.k * (w.dx * worldX + w.dz * worldZ) - this.gerstnerPhase[i]);
+                }
+                h += (Math.sin(worldX * 0.15 + ctx.chopT1a) * Math.cos(worldZ * 0.12 + ctx.chopT1b) * 0.6
+                    + Math.sin(worldX * 0.4 - ctx.chopT2a) * Math.cos(worldZ * 0.35 + ctx.chopT2b) * 0.15
+                    + Math.sin((worldX + worldZ) * 0.1 + ctx.chopT3) * 0.3) * ctx.chopAmp * ctx.waveScale;
+                let damping = 1.0;
+                let shoreH = 0.0;
+                let cutout = false;
+                for (let i = 0; i < ctx.shoreCnt; i++) {
+                    const src = ctx.shoreSrcs[i];
+                    const r = src.radius;
+                    const cr = src.cutoutRadius;
+                    if (r < 0.001 && cr < 0.001)
+                        continue;
+                    const sdx = worldX - src.x;
+                    const sdz = worldZ - src.z;
+                    const distSq = sdx * sdx + sdz * sdz;
+                    if (cr >= 0.001 && distSq < this.shoreCutoutRSq[i])
+                        cutout = true;
+                    if (r < 0.001)
+                        continue;
+                    if (distSq > this.shoreBandEndSq[i])
+                        continue;
+                    const dist = Math.sqrt(distSq);
+                    const flatR = r;
+                    const dampR = this.shoreDampR[i];
+                    const dampRange = this.shoreDampRange[i];
+                    let st = (dist - flatR) / dampRange;
+                    st = st < 0 ? 0 : st > 1 ? 1 : st;
+                    const smoothT = st * st * (3 - 2 * st);
+                    if (smoothT < damping)
+                        damping = smoothT;
+                    if (smoothT > 0.001) {
+                        const bandEnd = dampR + 20.0;
+                        const fadeW = 8.0;
+                        let ot = (dist - (bandEnd - fadeW)) / fadeW;
+                        ot = ot < 0 ? 0 : ot > 1 ? 1 : ot;
+                        const outerFade = 1.0 - ot * ot * (3 - 2 * ot);
+                        if (outerFade > 0.001) {
+                            const ringDist = dist - r;
+                            const shoal = 1.0 - smoothT * 0.6;
+                            const ringH = Math.sin(ringDist * 0.2 + ctx.shoreTime) * (1.5 * shoal);
+                            const distFade = Math.exp(-Math.max(ringDist - dampRange, 0.0) * 0.08);
+                            shoreH += ringH * distFade * outerFade;
+                        }
+                    }
+                }
+                h *= damping;
+                h += shoreH;
+                // Wake displacement from moving vessels
+                for (let i = 0; i < ctx.wakeCnt; i++) {
+                    const ws = ctx.wakeSrcs[i];
+                    if (ws.speed < 0.5)
+                        continue;
+                    const dx = worldX - ws.x;
+                    const dz = worldZ - ws.z;
+                    const dist = Math.sqrt(dx * dx + dz * dz);
+                    if (dist > 40.0)
+                        continue;
+                    const fwd = dx * ws.dirX + dz * ws.dirZ;
+                    const lat = -dx * ws.dirZ + dz * ws.dirX;
+                    if (fwd > 2.0)
+                        continue;
+                    const behind = -fwd;
+                    if (behind > 35.0)
+                        continue;
+                    const wakeSpread = 0.36;
+                    const wakeEdge = behind * wakeSpread;
+                    const latAbs = Math.abs(lat);
+                    if (latAbs > wakeEdge)
+                        continue;
+                    const lateralFade = 1.0 - (latAbs / Math.max(wakeEdge, 0.001));
+                    const distFade = Math.exp(-behind * 0.04);
+                    const speedFactor = Math.min(ws.speed / 10.0, 1.5);
+                    const k = 0.5;
+                    const ridge1 = Math.sin(behind * k - ctx.t * 3.0) * 0.4;
+                    const ridge2 = Math.sin(behind * k * 1.5 - ctx.t * 4.0) * 0.2;
+                    const wakeH = (ridge1 + ridge2) * distFade * lateralFade * speedFactor;
+                    h += wakeH * damping;
+                }
+                if (cutout)
+                    h = -1000;
+                heights[rowOffset + gx] = h;
+            }
+        }
+    }
+    getActiveChunks() {
+        return this.activeChunks;
+    }
+    sampleWaterAt(worldX, worldZ) {
+        if (waterCutout(worldX, worldZ, this.shoreSources, this.shoreCount))
+            return -1000;
+        // Sample from active chunks
+        const patchSize = this.buffer.getPatchSize();
+        let rawH = 0;
+        for (let _i = 0, _it = this.activeChunks, _n = _it.length; _i < _n; _i++) {
+            const chunk = _it[_i];
+            const gx = (worldX - chunk.originX) / patchSize;
+            const gz = (worldZ - chunk.originZ) / patchSize;
+            if (gx >= 0 && gx < CHUNK_GRID && gz >= 0 && gz < CHUNK_GRID) {
+                const x0 = Math.floor(gx);
+                const z0 = Math.floor(gz);
+                const x1 = Math.min(x0 + 1, CHUNK_GRID - 1);
+                const z1 = Math.min(z0 + 1, CHUNK_GRID - 1);
+                const fx = gx - x0;
+                const fz = gz - z0;
+                const h00 = chunk.heights[z0 * CHUNK_GRID + x0];
+                const h10 = chunk.heights[z0 * CHUNK_GRID + x1];
+                const h01 = chunk.heights[z1 * CHUNK_GRID + x0];
+                const h11 = chunk.heights[z1 * CHUNK_GRID + x1];
+                if (h00 < -100 || h10 < -100 || h01 < -100 || h11 < -100) {
+                    rawH = -1000;
+                    break;
+                }
+                const h0 = h00 * (1 - fx) + h10 * fx;
+                const h1 = h01 * (1 - fx) + h11 * fx;
+                rawH = h0 * (1 - fz) + h1 * fz;
+                break;
+            }
+        }
+        if (rawH < -100)
+            return -1000;
+        const damping = shoreDamping(worldX, worldZ, this.shoreSources, this.shoreCount);
+        const shore = shoreDisplacement(worldX, worldZ, this.time, this.shoreSources, this.shoreCount);
+        return rawH * damping + shore;
+    }
+    getTime() { return this.time; }
+}