@woosh/meep-engine 3.38.0 → 3.39.0

package/src/engine/graphics/ecs/water/WaterSerializationUpgrader_2_3.js

@@ -0,0 +1,45 @@
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+import { serialize_participating_medium } from "../../../../shade/renderer/medium/participating_medium_serialization.js";
+import { water_medium_default } from "../../../../shade/renderer/medium/water/water_presets.js";
+
+/**
+ * Version 2 described water by an authored body colour, shore colours, an RGB "extinction" times a
+ * scattering scale, and shore-wave and optical-normal controls. None of it was calibrated, so none
+ * of it maps onto a physical medium: mapping it would preserve a look nobody chose. Level, index
+ * of refraction and the reflection roughness carry over; the medium becomes the default physical
+ * preset (WATER_OPTICS_PLAN_2026_10_02.md §7.5, F1).
+ */
+export class WaterSerializationUpgrader_2_3 extends BinaryClassUpgrader {
+    __startVersion = 2;
+    __targetVersion = 3;
+
+    upgrade(source, target) {
+        const level = source.readFloat64();
+
+        source.readUint24(); // body colour
+        source.readFloat32(); // shore transition min
+        source.readFloat32(); // shore transition max
+        source.readUint24(); // shore colour
+        source.readFloat32(); // wave speed
+        source.readFloat32(); // wave amplitude
+        source.readFloat32(); // wave frequency
+        source.readFloat32(); // scattering scale
+
+        const ior = source.readFloat32();
+
+        source.readFloat32(); // optical normal strength
+        source.readFloat32(); // optical normal scale
+
+        const roughness = source.readFloat32();
+
+        source.readFloat32(); // extinction r
+        source.readFloat32(); // extinction g
+        source.readFloat32(); // extinction b
+
+        target.writeFloat64(level);
+        target.writeFloat32(ior);
+        target.writeFloat32(roughness);
+
+        serialize_participating_medium(target, water_medium_default());
+    }
+}

package/src/engine/graphics/ecs/water/WaterWaves.d.ts

@@ -0,0 +1,33 @@
+export default WaterWaves;
+/**
+ * What drives the waves of the {@link Water} on the same entity, for the primitive wave
+ * simulation.
+ *
+ * Kept apart from `Water` on purpose: `Water` describes the body and its optics, and says nothing
+ * about how the surface moves. The production surface simulation replaces this component, its
+ * system and its producer together, and `Water` stays as it is. A body without this component is
+ * simulated with no forcing, which is calm water — not a separate flat-water path.
+ */
+declare class WaterWaves {
+    /**
+     * Wind speed at 10 m, m/s. Sets the forcing, which grows as its square, and the slope variance
+     * of the waves the simulation's grid does not resolve (Cox-Munk).
+     * @type {Vector1}
+     */
+    windSpeed: Vector1;
+    /**
+     * Direction the wind blows towards, radians in the xz plane, measured from +x towards +z.
+     * @type {Vector1}
+     */
+    windDirection: Vector1;
+    fromJSON(json: any): void;
+    toJSON(): {
+        windSpeed: number;
+        windDirection: number;
+    };
+}
+declare namespace WaterWaves {
+    let typeName: string;
+}
+import Vector1 from "../../../../core/geom/Vector1.js";
+//# sourceMappingURL=WaterWaves.d.ts.map

package/src/engine/graphics/ecs/water/WaterWaves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterWaves.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterWaves.js"],"names":[],"mappings":";AAEA;;;;;;;;GAQG;AACH;IACI;;;;OAIG;IACH,WAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,eAFU,OAAO,CAEc;IAE/B,0BAQC;IAED;;;MAKC;CACJ;;;;oBAzCmB,kCAAkC"}

package/src/engine/graphics/ecs/water/WaterWaves.js

@@ -0,0 +1,46 @@
+import Vector1 from "../../../../core/geom/Vector1.js";
+
+/**
+ * What drives the waves of the {@link Water} on the same entity, for the primitive wave
+ * simulation.
+ *
+ * Kept apart from `Water` on purpose: `Water` describes the body and its optics, and says nothing
+ * about how the surface moves. The production surface simulation replaces this component, its
+ * system and its producer together, and `Water` stays as it is. A body without this component is
+ * simulated with no forcing, which is calm water — not a separate flat-water path.
+ */
+class WaterWaves {
+    /**
+     * Wind speed at 10 m, m/s. Sets the forcing, which grows as its square, and the slope variance
+     * of the waves the simulation's grid does not resolve (Cox-Munk).
+     * @type {Vector1}
+     */
+    windSpeed = new Vector1(3);
+
+    /**
+     * Direction the wind blows towards, radians in the xz plane, measured from +x towards +z.
+     * @type {Vector1}
+     */
+    windDirection = new Vector1(0);
+
+    fromJSON(json) {
+        if (typeof json.windSpeed === 'number') {
+            this.windSpeed.fromJSON(json.windSpeed);
+        }
+
+        if (typeof json.windDirection === 'number') {
+            this.windDirection.fromJSON(json.windDirection);
+        }
+    }
+
+    toJSON() {
+        return {
+            windSpeed: this.windSpeed.toJSON(),
+            windDirection: this.windDirection.toJSON(),
+        };
+    }
+}
+
+WaterWaves.typeName = "WaterWaves";
+
+export default WaterWaves;

package/src/engine/graphics/ecs/water/WaterWavesSerializationAdapter.d.ts

@@ -0,0 +1,17 @@
+export class WaterWavesSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof WaterWaves;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {WaterWaves} value
+     */
+    serialize(buffer: BinaryBuffer, value: WaterWaves): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {WaterWaves} value
+     */
+    deserialize(buffer: BinaryBuffer, value: WaterWaves): void;
+}
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import WaterWaves from "./WaterWaves.js";
+//# sourceMappingURL=WaterWavesSerializationAdapter.d.ts.map

package/src/engine/graphics/ecs/water/WaterWavesSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterWavesSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterWavesSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,yBAAmB;IAGnB;;;OAGG;IACH,uCAFW,UAAU,QAKpB;IAED;;;OAGG;IACH,yCAFW,UAAU,QAKpB;CACJ;gDAzB+C,gEAAgE;uBACzF,iBAAiB"}

package/src/engine/graphics/ecs/water/WaterWavesSerializationAdapter.js

@@ -0,0 +1,26 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import WaterWaves from "./WaterWaves.js";
+
+export class WaterWavesSerializationAdapter extends BinaryClassSerializationAdapter {
+
+    klass = WaterWaves;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {WaterWaves} value
+     */
+    serialize(buffer, value) {
+        buffer.writeFloat32(value.windSpeed.getValue());
+        buffer.writeFloat32(value.windDirection.getValue());
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {WaterWaves} value
+     */
+    deserialize(buffer, value) {
+        value.windSpeed.set(buffer.readFloat32());
+        value.windDirection.set(buffer.readFloat32());
+    }
+}

package/src/engine/graphics/texture/3d/scs3d_sample_linear.d.ts

@@ -1,4 +1,7 @@
 /**
+ * Trilinearly sample a single-channel 3D grid at the fractional position `(x, y, z)`, clamped to the
+ * grid's edge. The arithmetic is {@link scs3d_sample_linear_array}'s, which this packs its position
+ * for.
  *
  * @param {Float32Array} data
  * @param {number} res_x
@@ -10,4 +13,23 @@
  * @return {number}
  */
 export function scs3d_sample_linear(data: Float32Array, res_x: number, res_y: number, res_z: number, x: number, y: number, z: number): number;
+/**
+ * {@link scs3d_sample_linear} with the position read from `position[position_offset ..+2]` and the
+ * sample written to `out[out_offset]` (rounded to `out`'s element type, as a store of the returned
+ * value would be).
+ *
+ * The form for a kernel sampling once per cell: a call V8 does not inline boxes every number passed
+ * to it, and the one it returns, into a new heap object, and a kernel with several samples per cell
+ * runs out of inlining budget before it runs out of samples.
+ *
+ * @param {Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {Float32Array} data
+ * @param {number} res_x
+ * @param {number} res_y
+ * @param {number} res_z
+ * @param {Float64Array} position fractional `(x, y, z)` in the grid's index space
+ * @param {number} position_offset
+ */
+export function scs3d_sample_linear_array(out: Float32Array | Float64Array, out_offset: number, data: Float32Array, res_x: number, res_y: number, res_z: number, position: Float64Array, position_offset: number): void;
 //# sourceMappingURL=scs3d_sample_linear.d.ts.map

package/src/engine/graphics/texture/3d/scs3d_sample_linear.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scs3d_sample_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/3d/scs3d_sample_linear.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,0CATW,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CA0DjB"}
+{"version":3,"file":"scs3d_sample_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/3d/scs3d_sample_linear.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,0CATW,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAYjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,+CATW,YAAY,GAAC,YAAY,cACzB,MAAM,QACN,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,YACN,YAAY,mBACZ,MAAM,QA8DhB"}

package/src/engine/graphics/texture/3d/scs3d_sample_linear.js

@@ -1,7 +1,15 @@
 import { clamp } from "../../../../core/math/clamp.js";
 import { lerp } from "../../../../core/math/lerp.js";
 
+/** Where {@link scs3d_sample_linear} packs its position. */
+const scratch_position = new Float64Array(3);
+/** Where {@link scs3d_sample_linear} has its sample written. */
+const scratch_sample = new Float64Array(1);
+
 /**
+ * Trilinearly sample a single-channel 3D grid at the fractional position `(x, y, z)`, clamped to the
+ * grid's edge. The arithmetic is {@link scs3d_sample_linear_array}'s, which this packs its position
+ * for.
  *
  * @param {Float32Array} data
  * @param {number} res_x
@@ -13,6 +21,40 @@ import { lerp } from "../../../../core/math/lerp.js";
  * @return {number}
  */
 export function scs3d_sample_linear(data, res_x, res_y, res_z, x, y, z) {
+    const position = scratch_position;
+
+    position[0] = x;
+    position[1] = y;
+    position[2] = z;
+
+    scs3d_sample_linear_array(scratch_sample, 0, data, res_x, res_y, res_z, position, 0);
+
+    return scratch_sample[0];
+}
+
+/**
+ * {@link scs3d_sample_linear} with the position read from `position[position_offset ..+2]` and the
+ * sample written to `out[out_offset]` (rounded to `out`'s element type, as a store of the returned
+ * value would be).
+ *
+ * The form for a kernel sampling once per cell: a call V8 does not inline boxes every number passed
+ * to it, and the one it returns, into a new heap object, and a kernel with several samples per cell
+ * runs out of inlining budget before it runs out of samples.
+ *
+ * @param {Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {Float32Array} data
+ * @param {number} res_x
+ * @param {number} res_y
+ * @param {number} res_z
+ * @param {Float64Array} position fractional `(x, y, z)` in the grid's index space
+ * @param {number} position_offset
+ */
+export function scs3d_sample_linear_array(out, out_offset, data, res_x, res_y, res_z, position, position_offset) {
+    const x = position[position_offset];
+    const y = position[position_offset + 1];
+    const z = position[position_offset + 2];
+
     const x_max = res_x - 1;
     const y_max = res_y - 1;
     const z_max = res_z - 1;
@@ -67,5 +109,5 @@ export function scs3d_sample_linear(data, res_x, res_y, res_z, x, y, z) {
     const lerp_z1_y1 = lerp(x0y1z1, x1y1z1, f_x);
     const lerp_z1 = lerp(lerp_z1_y0, lerp_z1_y1, f_y);
 
-    return lerp(lerp_z0, lerp_z1, f_z);
+    out[out_offset] = lerp(lerp_z0, lerp_z1, f_z);
 }

package/src/engine/graphics/texture/sampler/Sampler2D.d.ts

@@ -1,6 +1,3 @@
-/**
- * @typedef {import("../../../../core/geom/Vector2.js").Vector2} Vector2
- */
 /**
  * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
  * Inspired by OpenGL's glsl sampler2d API
@@ -139,6 +136,7 @@ export class Sampler2D {
      */
     sampleChannelCatmullRomUV(u: number, v: number, channel: number): number;
     /**
+     * The arithmetic is {@link sampleChannelCatmullRomArray}'s, which this packs its position for.
      *
      * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
      * @param {number} x
@@ -147,6 +145,22 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelCatmullRom(x: number, y: number, channel: number): number;
+    /**
+     * {@link sampleChannelCatmullRom} with the position read from `position[position_offset ..+1]` and the
+     * sample written to `out[out_offset]`.
+     *
+     * Its nine bilinear taps go through {@link sampleChannelBilinearArray} the same way: a call V8 does
+     * not inline boxes every number passed to it, and the one it returns, into a new heap object, and
+     * nine bilinear filters are more than one function can inline.
+     *
+     * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number[]|Float32Array|Float64Array} position `[x, y]`, in texel space
+     * @param {number} position_offset
+     * @param {number} channel
+     */
+    sampleChannelCatmullRomArray(out: number[] | Float32Array | Float64Array, out_offset: number, position: number[] | Float32Array | Float64Array, position_offset: number, channel: number): void;
     /**
      *
      * @param {number} u
@@ -204,6 +218,7 @@ export class Sampler2D {
      */
     sampleChannelBilinearUV(u: number, v: number, channel: number): number;
     /**
+     * The arithmetic is {@link sampleChannelBilinearArray}'s, which this packs its position for.
      *
      * @param {number} x
      * @param {number} y
@@ -211,6 +226,17 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelBilinear(x: number, y: number, channel: number): number;
+    /**
+     * {@link sampleChannelBilinear} with the position read from `position[position_offset ..+1]` and the
+     * sample written to `out[out_offset]`, for the reason {@link sampleChannelCatmullRomArray} gives.
+     *
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number[]|Float32Array|Float64Array} position `[x, y]`, in texel space
+     * @param {number} position_offset
+     * @param {number} channel
+     */
+    sampleChannelBilinearArray(out: number[] | Float32Array | Float64Array, out_offset: number, position: number[] | Float32Array | Float64Array, position_offset: number, channel: number): void;
     /**
      *
      * @param {number} u

package/src/engine/graphics/texture/sampler/Sampler2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"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"}

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -23,6 +23,18 @@ import { computeHashFloat } from "../../../../core/primitives/numbers/computeHas
  * @typedef {import("../../../../core/geom/Vector2.js").Vector2} Vector2
  */
 
+/** Where {@link Sampler2D#sampleChannelBilinear} packs its position and has its sample written. */
+const scratch_bilinear_position = new Float64Array(2);
+const scratch_bilinear_sample = new Float64Array(1);
+
+/** Where {@link Sampler2D#sampleChannelCatmullRom} packs its position and has its sample written. */
+const scratch_catmull_rom_position = new Float64Array(2);
+const scratch_catmull_rom_sample = new Float64Array(1);
+
+/** {@link Sampler2D#sampleChannelCatmullRomArray}'s nine bilinear taps, `(x, y)` pairs, and their texels. */
+const scratch_catmull_rom_taps = new Float64Array(18);
+const scratch_catmull_rom_texels = new Float64Array(9);
+
 /**
  * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
  * Inspired by OpenGL's glsl sampler2d API
@@ -118,6 +130,7 @@ export class Sampler2D {
     }
 
     /**
+     * The arithmetic is {@link sampleChannelCatmullRomArray}'s, which this packs its position for.
      *
      * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
      * @param {number} x
@@ -126,6 +139,35 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelCatmullRom(x, y, channel) {
+        const position = scratch_catmull_rom_position;
+
+        position[0] = x;
+        position[1] = y;
+
+        this.sampleChannelCatmullRomArray(scratch_catmull_rom_sample, 0, position, 0, channel);
+
+        return scratch_catmull_rom_sample[0];
+    }
+
+    /**
+     * {@link sampleChannelCatmullRom} with the position read from `position[position_offset ..+1]` and the
+     * sample written to `out[out_offset]`.
+     *
+     * Its nine bilinear taps go through {@link sampleChannelBilinearArray} the same way: a call V8 does
+     * not inline boxes every number passed to it, and the one it returns, into a new heap object, and
+     * nine bilinear filters are more than one function can inline.
+     *
+     * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number[]|Float32Array|Float64Array} position `[x, y]`, in texel space
+     * @param {number} position_offset
+     * @param {number} channel
+     */
+    sampleChannelCatmullRomArray(out, out_offset, position, position_offset, channel) {
+        const x = position[position_offset];
+        const y = position[position_offset + 1];
+
         // We're going to sample a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
         // down the sample location to get the exact center of our "starting" texel. The starting texel will be at
         // location [1, 1] in the grid, where [0, 0] is the top-left corner.
@@ -167,21 +209,41 @@ export class Sampler2D {
         const texPos12_x = texPos1_x + offset12_x;
         const texPos12_y = texPos1_y + offset12_y;
 
+        // The nine taps, row by row: (x, y) pairs in, filtered texels out.
+        const taps = scratch_catmull_rom_taps;
+        const texels = scratch_catmull_rom_texels;
+
+        taps[0] = texPos0_x; taps[1] = texPos0_y;
+        taps[2] = texPos12_x; taps[3] = texPos0_y;
+        taps[4] = texPos3_x; taps[5] = texPos0_y;
+
+        taps[6] = texPos0_x; taps[7] = texPos12_y;
+        taps[8] = texPos12_x; taps[9] = texPos12_y;
+        taps[10] = texPos3_x; taps[11] = texPos12_y;
+
+        taps[12] = texPos0_x; taps[13] = texPos3_y;
+        taps[14] = texPos12_x; taps[15] = texPos3_y;
+        taps[16] = texPos3_x; taps[17] = texPos3_y;
+
+        for (let i = 0; i < 9; i++) {
+            this.sampleChannelBilinearArray(texels, i, taps, 2 * i, channel);
+        }
+
         let result = 0.0;
 
-        result += this.sampleChannelBilinear(texPos0_x, texPos0_y, channel) * w0_x * w0_y;
-        result += this.sampleChannelBilinear(texPos12_x, texPos0_y, channel) * w12_x * w0_y;
-        result += this.sampleChannelBilinear(texPos3_x, texPos0_y, channel) * w3_x * w0_y;
+        result += texels[0] * w0_x * w0_y;
+        result += texels[1] * w12_x * w0_y;
+        result += texels[2] * w3_x * w0_y;
 
-        result += this.sampleChannelBilinear(texPos0_x, texPos12_y, channel) * w0_x * w12_y;
-        result += this.sampleChannelBilinear(texPos12_x, texPos12_y, channel) * w12_x * w12_y;
-        result += this.sampleChannelBilinear(texPos3_x, texPos12_y, channel) * w3_x * w12_y;
+        result += texels[3] * w0_x * w12_y;
+        result += texels[4] * w12_x * w12_y;
+        result += texels[5] * w3_x * w12_y;
 
-        result += this.sampleChannelBilinear(texPos0_x, texPos3_y, channel) * w0_x * w3_y;
-        result += this.sampleChannelBilinear(texPos12_x, texPos3_y, channel) * w12_x * w3_y;
-        result += this.sampleChannelBilinear(texPos3_x, texPos3_y, channel) * w3_x * w3_y;
+        result += texels[6] * w0_x * w3_y;
+        result += texels[7] * w12_x * w3_y;
+        result += texels[8] * w3_x * w3_y;
 
-        return result;
+        out[out_offset] = result;
     }
 
     /**
@@ -367,6 +429,7 @@ export class Sampler2D {
     }
 
     /**
+     * The arithmetic is {@link sampleChannelBilinearArray}'s, which this packs its position for.
      *
      * @param {number} x
      * @param {number} y
@@ -375,9 +438,33 @@ export class Sampler2D {
      */
     sampleChannelBilinear(x, y, channel) {
         assert.isNumber(x, 'x');
-        assert.notNaN(x, 'x');
-
         assert.isNumber(y, 'y');
+
+        const position = scratch_bilinear_position;
+
+        position[0] = x;
+        position[1] = y;
+
+        this.sampleChannelBilinearArray(scratch_bilinear_sample, 0, position, 0, channel);
+
+        return scratch_bilinear_sample[0];
+    }
+
+    /**
+     * {@link sampleChannelBilinear} with the position read from `position[position_offset ..+1]` and the
+     * sample written to `out[out_offset]`, for the reason {@link sampleChannelCatmullRomArray} gives.
+     *
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} out_offset
+     * @param {number[]|Float32Array|Float64Array} position `[x, y]`, in texel space
+     * @param {number} position_offset
+     * @param {number} channel
+     */
+    sampleChannelBilinearArray(out, out_offset, position, position_offset, channel) {
+        const x = position[position_offset];
+        const y = position[position_offset + 1];
+
+        assert.notNaN(x, 'x');
         assert.notNaN(y, 'y');
 
         assert.isNonNegativeInteger(channel, 'channel');
@@ -427,7 +514,8 @@ export class Sampler2D {
 
         if (x0 === x1 && y0 === y1) {
             // exactly sampled in the center of the pixel, no interpolation required
-            return q0;
+            out[out_offset] = q0;
+            return;
         }
 
         //
@@ -451,7 +539,7 @@ export class Sampler2D {
         const s0 = lerp(q0, q1, xd);
         const s1 = lerp(p0, p1, xd);
 
-        return lerp(s0, s1, yd);
+        out[out_offset] = lerp(s0, s1, yd);
     }
 
     /**

package/src/engine/graphics3/WaterSystem.d.ts

@@ -13,18 +13,20 @@ export class WaterSystem extends System<any> {
      */
     constructor(graphics: GraphicsEngine);
     dependencies: (typeof Water)[];
+    components_used: ResourceAccessSpecification<typeof WaterWaves>[];
     get settings(): {
         enabled: boolean;
         max_distance: number;
         distance_tolerance: number;
         max_updates: number;
         fallback_steps: number;
-        mode: number; /**
-         * @type {GPUWaterRenderer}
-         */
+        mode: number;
         reflections: number;
         debug_view: number;
+        inscatter_segments: number;
     };
+    /** The surface producer, for settings such as its grid resolution. */
+    get waves(): GPUWaterWaveSimulation;
     /** The registered channel, for diagnostics such as testing registration order. */
     get transparency_channel(): GPUWaterRenderer;
     request_probe(uv: any): Promise<any>;
@@ -43,6 +45,25 @@ export class WaterSystem extends System<any> {
      * @param {FrameContext} frame
      */
     record(frame: FrameContext): void;
+    /**
+     * Record the surface producer: this frame's wave steps and the surface interface every water
+     * pass reads. At the head of the frame, so everything that reads it is recorded after.
+     *
+     * @param {FrameContext} frame
+     */
+    record_surface(frame: FrameContext): void;
+    /**
+     * Kick the surface of an entity's water, as a boat or a splash would: a vertical velocity
+     * `strength` m/s at `position`, falling off over `radius` m. Applied on the next frame that
+     * steps; at most {@link WATER_WAVE_IMPULSE_LIMIT} a frame per body, the rest wait for the
+     * following frames.
+     *
+     * @param {number} entity the entity carrying the {@link Water}
+     * @param {number[]} position world x, y, z; y is ignored
+     * @param {number} radius m
+     * @param {number} strength m/s, positive upwards
+     */
+    splash(entity: number, position: number[], radius: number, strength: number): void;
     /**
      * @param {Water} water
      * @param {number} entity
@@ -68,8 +89,23 @@ export class WaterExtension extends RenderExtension {
     record(frame: any): void;
     #private;
 }
+/**
+ * Records the water surface producer at {@link FramePhase.FrameStart}, so the surface exists before
+ * anything in the frame reads it.
+ */
+export class WaterSurfaceExtension extends RenderExtension {
+    /**
+     * @param {WaterSystem} system
+     */
+    constructor(system: WaterSystem);
+    record(frame: any): void;
+    #private;
+}
 import { System } from "../ecs/System.js";
 import Water from "../graphics/ecs/water/Water.js";
+import WaterWaves from "../graphics/ecs/water/WaterWaves.js";
+import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
+import { GPUWaterWaveSimulation } from "../../shade/renderer/water/surface/GPUWaterWaveSimulation.js";
 import { GPUWaterRenderer } from "../../shade/renderer/water/GPUWaterRenderer.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
 //# sourceMappingURL=WaterSystem.d.ts.map

package/src/engine/graphics3/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/WaterSystem.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH;IA6DI;;OAEG;IACH,sCAMC;IArED,+BAAuB;IA6BvB;;;;;;sBAtBA;;WAEG;;;MAoB+C;IAElD,kFAAkF;IAClF,6CAAqD;IAErD,qCAA8D;IAG9D,0BAIC;IALD,mBAAiC;IAcjC;;;;;OAKG;IACH,+BAEC;IAaD,2CAMC;IAED,4CAWC;IAED;;OAEG;IACH,kCAGC;IAED;;;OAGG;IACH,YAHW,KAAK,UACL,MAAM,QA+BhB;IAED;;;OAGG;IACH,cAHW,KAAK,UACL,MAAM,QAgBhB;IAED,6BAgBC;;CA4FJ;AAED;;;GAGG;AACH;IAWI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBArTsB,kBAAkB;kBAHvB,gCAAgC;iCAIjB,gDAAgD;gCAGjD,mDAAmD"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/WaterSystem.js"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH;IA4FI;;OAEG;IACH,sCAMC;IApGD,+BAAuB;IAEvB,kEAGE;IAoDF;;;;;;;;;;MAAkD;IAElD,sEAAsE;IACtE,oCAAmC;IAEnC,kFAAkF;IAClF,6CAAqD;IAErD,qCAA8D;IAG9D,0BAIC;IALD,mBAAiC;IAcjC;;;;;OAKG;IACH,+BAEC;IAaD,2CAQC;IAED,4CAkBC;IAED;;OAEG;IACH,kCAGC;IAED;;;;;OAKG;IACH,0CAWC;IAED;;;;;;;;;;OAUG;IACH,eALW,MAAM,YACN,MAAM,EAAE,UACR,MAAM,YACN,MAAM,QAgBhB;IAED;;;OAGG;IACH,YAHW,KAAK,UACL,MAAM,QA+BhB;IAED;;;OAGG;IACH,cAHW,KAAK,UACL,MAAM,QAgBhB;IAED,6BAiBC;;CAgFJ;AAED;;;GAGG;AACH;IAWI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;AAED;;;GAGG;AACH;IAUI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAjasB,kBAAkB;kBAJvB,gCAAgC;uBAC3B,qCAAqC;4CAKhB,iDAAiD;uCAGtD,8DAA8D;iCAFpE,gDAAgD;gCAMjD,mDAAmD"}