@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"WaterSerializationUpgrader_3_4.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSerializationUpgrader_3_4.js"],"names":[],"mappings":"AAEA,oGAAoG;AACpG;IAGI,gBAEC;CACJ;oCATmC,oDAAoD"}

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

@@ -0,0 +1,10 @@
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+
+/** A component upgrader cannot create the geometry and transform needed to retain old placement. */
+export class WaterSerializationUpgrader_3_4 extends BinaryClassUpgrader {
+    __startVersion = 3;
+    __targetVersion = 4;
+    upgrade() {
+        throw new Error('Legacy Water placement must be migrated to MeshletGeometry and Transform64 before loading');
+    }
+}

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
+ * tessellates its authored rest surface and allocates no wave grid until a splash is queued.
+ */
+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 mesh's local 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
+ * tessellates its authored rest surface and allocates no wave grid until a splash is queued.
+ */
+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 mesh's local 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/graphics/texture/sampler/sampler2d_to_avif.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_to_avif.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_avif.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gEARW,MAAM,YACN,MAAM,+BAEJ,UAAU,CAmCtB"}
+{"version":3,"file":"sampler2d_to_avif.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_avif.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gEARW,MAAM,YACN,MAAM,+BAEJ,UAAU,CAmCtB"}

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

@@ -1,7 +1,6 @@
 import { MC_BT_709, TC_SMPTE_2084 } from "../../../../format/image/avif/av1/tables/av1_symbols.js";
 import { SDR_WHITE_NITS } from "../../../../core/color/PQ/PQ_constants.js";
 import { SUBSAMPLING_420, SUBSAMPLING_422, encode_avif } from "../../../../format/image/avif/api/encode_avif.js";
-import { half_to_float_uint16 } from "../../../../core/binary/half_to_float_uint16.js";
 
 /**
  * Encode a sampler as an AVIF file.
@@ -31,7 +30,7 @@ export function sampler2d_to_avif(sampler, quality = 0.75, options = {}, encoder
 
     const data = sampler.data;
 
-    const hdr = data instanceof Uint16Array;
+    const hdr = data instanceof Float16Array || data instanceof Uint16Array;
 
     const rgba = to_rgba(data, item_size, width, height, hdr);
 
@@ -58,7 +57,7 @@ export function sampler2d_to_avif(sampler, quality = 0.75, options = {}, encoder
 /**
  * Expand a sampler's samples to interleaved RGBA of the kind the encoder takes.
  *
- * @param {Uint8Array|Uint8ClampedArray|Uint16Array|Float32Array|Float64Array} data
+ * @param {Uint8Array|Uint8ClampedArray|Uint16Array|Float16Array|Float32Array|Float64Array} data
  * @param {number} item_size
  * @param {number} width
  * @param {number} height
@@ -69,6 +68,10 @@ function to_rgba(data, item_size, width, height, hdr) {
     const count = width * height;
 
     if (hdr) {
+        // Keep accepting packed binary16 samplers while reading native halves as numbers.
+        const values = data instanceof Uint16Array
+            ? new Float16Array(data.buffer, data.byteOffset, data.length)
+            : data;
         const out = new Float32Array(count * 4);
 
         for (let i = 0; i < count; i++) {
@@ -76,12 +79,12 @@ function to_rgba(data, item_size, width, height, hdr) {
             const destination = i * 4;
 
             for (let c = 0; c < 3; c++) {
-                const value = c < item_size ? half_to_float_uint16(data[source + c]) : 0;
+                const value = c < item_size ? values[source + c] : 0;
 
                 out[destination + c] = Math.max(value, 0);
             }
 
-            out[destination + 3] = item_size > 3 ? Math.min(Math.max(half_to_float_uint16(data[source + 3]), 0), 1) : 1;
+            out[destination + 3] = item_size > 3 ? Math.min(Math.max(values[source + 3], 0), 1) : 1;
         }
 
         return out;