@woosh/meep-engine 3.14.1 → 3.14.3

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

@@ -0,0 +1,42 @@
+import { COLOUR_SPACE_LINEAR, COLOUR_SPACE_SIGNAL, CHROMA_UPSAMPLING_BEST } from "../../../../format/image/avif/api/convert_to_rgba.js";
+import { SDR_WHITE_NITS } from "../../../../core/color/PQ/PQ_constants.js";
+import { Sampler2D } from "./Sampler2D.js";
+import { decode_avif } from "../../../../format/image/avif/api/decode_avif.js";
+
+/**
+ * Decode an AVIF file into a sampler the renderer can use.
+ *
+ * High dynamic range images come back as half floats holding linear light, which is what the
+ * renderer's textures are; everything else comes back as eight bit samples.
+ *
+ * The linear normalisation is the renderer's: `1.0` is SDR reference white,
+ * {@link SDR_WHITE_NITS} nits per ITU-R BT.2408, which is the unit every sampler in the engine is
+ * already in. Naming it to the decoder is what makes this the exact inverse of
+ * {@link sampler2d_to_avif}, which names the same white to the encoder.
+ *
+ * @param {ArrayBuffer|Uint8Array} buffer
+ * @param {object} [options]
+ * @param {boolean} [options.hdr] decode to linear half floats rather than eight bit samples
+ * @param {AvifDecoder} [decoder] pass one back in to decode many images without reallocating
+ * @returns {Sampler2D}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function avif_to_sampler2d(buffer, options = {}, decoder = undefined) {
+    const hdr = options.hdr === true;
+
+    const decoded = decode_avif(
+        buffer,
+        {
+            bit_depth: hdr ? 12 : 8,
+            output_float16: hdr,
+            output_colour_space: hdr ? COLOUR_SPACE_LINEAR : COLOUR_SPACE_SIGNAL,
+            linear_reference_nits: SDR_WHITE_NITS,
+            chroma_upsampling: CHROMA_UPSAMPLING_BEST
+        },
+        decoder
+    );
+
+    return new Sampler2D(decoded.data, 4, decoded.width, decoded.height);
+}

package/src/engine/graphics/texture/sampler/compare/sampler2d_compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_compare.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/compare/sampler2d_compare.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+DAFa,MAAM,CAuFlB"}

package/src/engine/graphics/texture/sampler/compare/sampler2d_compare.js

@@ -0,0 +1,94 @@
+import { array_copy } from "../../../../../core/collection/array/array_copy.js";
+
+/**
+ *
+ * @param {Sampler2D} a
+ * @param {Sampler2D} b
+ * @returns {number} similarity score. 0 - nothing in common. 1 - identical.
+ */
+export function sampler2d_compare(a, b) {
+    if (a === b) {
+        return 1.0;
+    }
+
+    if (
+        a.width !== b.width
+        || a.height !== b.height
+        || a.itemSize !== b.itemSize
+    ) {
+
+        // quick exit
+        return 0;
+    }
+
+    const width = a.width;
+    const height = a.height;
+    const itemSize = a.itemSize;
+
+    const sample_a = new Array(itemSize);
+    const sample_b = new Array(itemSize);
+
+    let difference_sum = 0;
+
+    const value_min = new Array(itemSize);
+    const value_max = new Array(itemSize);
+
+    for (let i = 0; i < itemSize; i++) {
+        value_min[i] = Infinity;
+        value_max[i] = -Infinity;
+    }
+
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+
+            const offset = (y * width + x) * itemSize;
+
+            // read texels
+            array_copy(a.data, offset, sample_a, 0, itemSize);
+            array_copy(b.data, offset, sample_b, 0, itemSize);
+
+            // compare
+            let sum = 0;
+            for (let i = 0; i < itemSize; i++) {
+                const sample_value_a = sample_a[i];
+                const sample_value_b = sample_b[i];
+
+                const diff = sample_value_a - sample_value_b;
+                sum += diff * diff;
+
+                //
+                value_max[i] = Math.max(value_max[i], sample_value_a, sample_value_b);
+                value_min[i] = Math.min(value_min[i], sample_value_a, sample_value_b);
+            }
+
+            const texel_difference = Math.sqrt(sum);
+
+            difference_sum += texel_difference;
+        }
+    }
+
+    if (difference_sum === 0) {
+        return 1;
+    }
+
+    const total_texel_count = width * height;
+
+    const mean_texel_difference = difference_sum / total_texel_count;
+
+    // normalize difference
+    let bounds_vector_length = 0;
+    for (let i = 0; i < itemSize; i++) {
+        const span = value_max[i] - value_min[i];
+        bounds_vector_length += span * span;
+    }
+
+    if (bounds_vector_length === 0) {
+        // all values are the same.
+        // avoids NaN from division by zero.
+        return 1;
+    }
+
+    bounds_vector_length = Math.sqrt(bounds_vector_length);
+
+    return 1.0 - (mean_texel_difference / bounds_vector_length);
+}

package/src/engine/graphics/texture/sampler/compare/sampler2d_max_absolute_difference.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The largest difference between corresponding samples of two images, in the units the storage
+ * holds: levels for integer samplers, plain values for float ones.
+ *
+ * The companion to {@link sampler2d_psnr}, and the bound that catches what an average cannot. A
+ * handful of blocks decoded from the wrong endpoints move a whole image's PSNR by a fraction of a
+ * decibel while moving their own texels across the entire range, and this is the number that sees
+ * them. The transcode specs assert both.
+ *
+ * `channels` says how many leading channels take part, as for {@link sampler2d_psnr}: it defaults to
+ * the samplers' shared channel count and must be given when the counts differ.
+ *
+ * @param {Sampler2D} reference
+ * @param {Sampler2D} test same dimensions as `reference`
+ * @param {number} [channels] leading channels to compare; required when the channel counts differ
+ * @returns {number} zero for identical inputs
+ */
+export function sampler2d_max_absolute_difference(reference: Sampler2D, test: Sampler2D, channels?: number): number;
+//# sourceMappingURL=sampler2d_max_absolute_difference.d.ts.map

package/src/engine/graphics/texture/sampler/compare/sampler2d_max_absolute_difference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_max_absolute_difference.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/compare/sampler2d_max_absolute_difference.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,oGAHW,MAAM,GACJ,MAAM,CA4ClB"}

package/src/engine/graphics/texture/sampler/compare/sampler2d_max_absolute_difference.js

@@ -0,0 +1,62 @@
+import { assert } from "../../../../../core/assert.js";
+
+/**
+ * The largest difference between corresponding samples of two images, in the units the storage
+ * holds: levels for integer samplers, plain values for float ones.
+ *
+ * The companion to {@link sampler2d_psnr}, and the bound that catches what an average cannot. A
+ * handful of blocks decoded from the wrong endpoints move a whole image's PSNR by a fraction of a
+ * decibel while moving their own texels across the entire range, and this is the number that sees
+ * them. The transcode specs assert both.
+ *
+ * `channels` says how many leading channels take part, as for {@link sampler2d_psnr}: it defaults to
+ * the samplers' shared channel count and must be given when the counts differ.
+ *
+ * @param {Sampler2D} reference
+ * @param {Sampler2D} test same dimensions as `reference`
+ * @param {number} [channels] leading channels to compare; required when the channel counts differ
+ * @returns {number} zero for identical inputs
+ */
+export function sampler2d_max_absolute_difference(reference, test, channels = undefined) {
+    // the same admission as sampler2d_psnr, so the two can always be taken on the same pair
+    assert.equal(reference.width, test.width, 'reference.width');
+    assert.equal(reference.height, test.height, 'reference.height');
+
+    if (channels === undefined) {
+        assert.equal(
+            reference.itemSize, test.itemSize,
+            'the samplers differ in channel count, so the number of channels to compare must be given'
+        );
+
+        channels = reference.itemSize;
+    }
+
+    assert.isPositiveInteger(channels, 'channels');
+    assert.lessThanOrEqual(channels, reference.itemSize, 'channels exceed reference.itemSize');
+    assert.lessThanOrEqual(channels, test.itemSize, 'channels exceed test.itemSize');
+
+    const texel_count = reference.width * reference.height;
+
+    const reference_stride = reference.itemSize;
+    const test_stride = test.itemSize;
+
+    const reference_data = reference.data;
+    const test_data = test.data;
+
+    let max = 0;
+
+    for (let i = 0; i < texel_count; i++) {
+        const reference_offset = i * reference_stride;
+        const test_offset = i * test_stride;
+
+        for (let c = 0; c < channels; c++) {
+            const delta = Math.abs(reference_data[reference_offset + c] - test_data[test_offset + c]);
+
+            if (delta > max) {
+                max = delta;
+            }
+        }
+    }
+
+    return max;
+}

package/src/engine/graphics/texture/sampler/compare/sampler2d_psnr.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Peak signal-to-noise ratio of `test` against `reference`, in decibels.
+ *
+ * The number codecs are measured by: the storage's peak value squared over the mean squared error of
+ * every compared sample, on a log scale where each doubling of the error costs six decibels. A
+ * one-level error in every 8-bit sample is 48.13 dB; identical images are `Infinity`.
+ *
+ * It is a pixel statistic and says nothing about how the error looks. A tint nobody would notice and
+ * a displaced edge everybody would can score the same, which is why the renderer's regression gate is
+ * {@link sampler2d_flip_ldr} instead. PSNR earns its place beside it as the scale the codec
+ * literature and the reference transcoders publish, so a transcode here can be held against a figure
+ * from there.
+ *
+ * `channels` says how many leading channels take part, and defaults to the samplers' shared channel
+ * count. Samplers with different channel counts must be told: an RGBA decode against RGB truth is
+ * `sampler2d_psnr(decoded, truth, 3)`. Whether alpha counts moves the figure — an opaque texture's
+ * alpha contributes no error and a quarter of the samples, which is worth 1.25 dB — so the choice is
+ * made at the call site rather than in here.
+ *
+ * `peak` defaults from the storage: the largest value an integer type holds, one for floating point.
+ * Ten-bit samples in sixteen-bit storage, or HDR floats, need it given.
+ *
+ * @param {Sampler2D} reference
+ * @param {Sampler2D} test same dimensions as `reference`
+ * @param {number} [channels] leading channels to compare; required when the channel counts differ
+ * @param {number} [peak] the largest possible sample value
+ * @returns {number} decibels, `Infinity` for identical inputs
+ */
+export function sampler2d_psnr(reference: Sampler2D, test: Sampler2D, channels?: number, peak?: number): number;
+//# sourceMappingURL=sampler2d_psnr.d.ts.map

package/src/engine/graphics/texture/sampler/compare/sampler2d_psnr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_psnr.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/compare/sampler2d_psnr.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iFAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAuDlB"}

package/src/engine/graphics/texture/sampler/compare/sampler2d_psnr.js

@@ -0,0 +1,115 @@
+import { assert } from "../../../../../core/assert.js";
+
+/**
+ * The largest value a sampler's storage can hold, which is what PSNR measures the error against.
+ * Floating point storage has no such value; the convention for it is a normalized range, so one.
+ *
+ * @param {ArrayLike<number>} data
+ * @returns {number}
+ */
+function storage_peak(data) {
+    switch (data.constructor) {
+        case Uint8Array:
+        case Uint8ClampedArray:
+            return 0xFF;
+        case Uint16Array:
+            return 0xFFFF;
+        case Uint32Array:
+            return 0xFFFFFFFF;
+        case Int8Array:
+            return 0x7F;
+        case Int16Array:
+            return 0x7FFF;
+        case Int32Array:
+            return 0x7FFFFFFF;
+        case Float16Array:
+        case Float32Array:
+        case Float64Array:
+            return 1;
+        default:
+            throw new Error(`${data.constructor.name} storage has no peak to infer, pass one`);
+    }
+}
+
+/**
+ * Peak signal-to-noise ratio of `test` against `reference`, in decibels.
+ *
+ * The number codecs are measured by: the storage's peak value squared over the mean squared error of
+ * every compared sample, on a log scale where each doubling of the error costs six decibels. A
+ * one-level error in every 8-bit sample is 48.13 dB; identical images are `Infinity`.
+ *
+ * It is a pixel statistic and says nothing about how the error looks. A tint nobody would notice and
+ * a displaced edge everybody would can score the same, which is why the renderer's regression gate is
+ * {@link sampler2d_flip_ldr} instead. PSNR earns its place beside it as the scale the codec
+ * literature and the reference transcoders publish, so a transcode here can be held against a figure
+ * from there.
+ *
+ * `channels` says how many leading channels take part, and defaults to the samplers' shared channel
+ * count. Samplers with different channel counts must be told: an RGBA decode against RGB truth is
+ * `sampler2d_psnr(decoded, truth, 3)`. Whether alpha counts moves the figure — an opaque texture's
+ * alpha contributes no error and a quarter of the samples, which is worth 1.25 dB — so the choice is
+ * made at the call site rather than in here.
+ *
+ * `peak` defaults from the storage: the largest value an integer type holds, one for floating point.
+ * Ten-bit samples in sixteen-bit storage, or HDR floats, need it given.
+ *
+ * @param {Sampler2D} reference
+ * @param {Sampler2D} test same dimensions as `reference`
+ * @param {number} [channels] leading channels to compare; required when the channel counts differ
+ * @param {number} [peak] the largest possible sample value
+ * @returns {number} decibels, `Infinity` for identical inputs
+ */
+export function sampler2d_psnr(reference, test, channels = undefined, peak = undefined) {
+    assert.equal(reference.width, test.width, 'reference.width');
+    assert.equal(reference.height, test.height, 'reference.height');
+
+    if (channels === undefined) {
+        assert.equal(
+            reference.itemSize, test.itemSize,
+            'the samplers differ in channel count, so the number of channels to compare must be given'
+        );
+
+        channels = reference.itemSize;
+    }
+
+    assert.isPositiveInteger(channels, 'channels');
+    assert.lessThanOrEqual(channels, reference.itemSize, 'channels exceed reference.itemSize');
+    assert.lessThanOrEqual(channels, test.itemSize, 'channels exceed test.itemSize');
+
+    if (peak === undefined) {
+        peak = storage_peak(reference.data);
+    }
+
+    assert.isNumber(peak, 'peak');
+    assert.notNaN(peak, 'peak');
+    assert.greaterThan(peak, 0, 'peak');
+
+    const texel_count = reference.width * reference.height;
+
+    const reference_stride = reference.itemSize;
+    const test_stride = test.itemSize;
+
+    const reference_data = reference.data;
+    const test_data = test.data;
+
+    let squared = 0;
+
+    for (let i = 0; i < texel_count; i++) {
+        const reference_offset = i * reference_stride;
+        const test_offset = i * test_stride;
+
+        for (let c = 0; c < channels; c++) {
+            const delta = reference_data[reference_offset + c] - test_data[test_offset + c];
+
+            squared += delta * delta;
+        }
+    }
+
+    if (squared === 0) {
+        return Infinity;
+    }
+
+    const mean = squared / (texel_count * channels);
+
+    return 10 * Math.log10(peak * peak / mean);
+}

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

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

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

@@ -0,0 +1,108 @@
+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.
+ *
+ * A half float sampler is taken to hold linear light in the renderer's normalisation — `1.0` is
+ * SDR reference white, {@link SDR_WHITE_NITS} nits per ITU-R BT.2408 — and is coded through the PQ
+ * transfer function at twelve bits, which is what high dynamic range content needs. An eight bit
+ * sampler is coded as ordinary sRGB.
+ *
+ * {@link avif_to_sampler2d} is the exact inverse of this, in those same units: it names the same
+ * white to the decoder, so a sampler that goes through the pair comes back as itself.
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} [quality] `0 .. 1`
+ * @param {object} [options]
+ * @param {Av1EncodeContext} [encoder] pass one back in to encode many images without reallocating
+ * @returns {Uint8Array}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sampler2d_to_avif(sampler, quality = 0.75, options = {}, encoder = undefined) {
+    const width = sampler.width;
+    const height = sampler.height;
+
+    const item_size = sampler.itemSize;
+
+    const data = sampler.data;
+
+    const hdr = data instanceof Uint16Array;
+
+    const rgba = to_rgba(data, item_size, width, height, hdr);
+
+    if (hdr) {
+        return encode_avif({ data: rgba, width, height }, {
+            quality: Math.round(quality * 100),
+            bit_depth: 12,
+            subsampling: options.subsampling ?? SUBSAMPLING_422,
+            matrix_coefficients: MC_BT_709,
+            transfer_characteristics: TC_SMPTE_2084,
+            input_is_linear: true,
+            linear_reference_nits: SDR_WHITE_NITS,
+            alpha: options.alpha === true
+        }, encoder);
+    }
+
+    return encode_avif({ data: rgba, width, height }, {
+        quality: Math.round(quality * 100),
+        subsampling: options.subsampling ?? SUBSAMPLING_420,
+        alpha: options.alpha === true
+    }, encoder);
+}
+
+/**
+ * Expand a sampler's samples to interleaved RGBA of the kind the encoder takes.
+ *
+ * @param {Uint8Array|Uint8ClampedArray|Uint16Array|Float32Array|Float64Array} data
+ * @param {number} item_size
+ * @param {number} width
+ * @param {number} height
+ * @param {boolean} hdr whether the samples are half floats holding linear light
+ * @returns {Uint8ClampedArray|Float32Array}
+ */
+function to_rgba(data, item_size, width, height, hdr) {
+    const count = width * height;
+
+    if (hdr) {
+        const out = new Float32Array(count * 4);
+
+        for (let i = 0; i < count; i++) {
+            const source = i * item_size;
+            const destination = i * 4;
+
+            for (let c = 0; c < 3; c++) {
+                const value = c < item_size ? half_to_float_uint16(data[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;
+        }
+
+        return out;
+    }
+
+    if (item_size === 4) {
+        return data;
+    }
+
+    const out = new Uint8ClampedArray(count * 4);
+
+    for (let i = 0; i < count; i++) {
+        const source = i * item_size;
+        const destination = i * 4;
+
+        for (let c = 0; c < 3; c++) {
+            out[destination + c] = c < item_size ? data[source + c] : 0;
+        }
+
+        out[destination + 3] = item_size > 3 ? data[source + 3] : 255;
+    }
+
+    return out;
+}

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

@@ -1,7 +1,13 @@
 /**
+ * Converts a sampler's values to half precision.
+ *
+ * The result is backed by a `Float16Array`, so it reads back as numbers like any other float sampler,
+ * and its bytes are the binary16 a 16-bit float texture takes. Values are converted as they are, not
+ * normalized: an 8-bit 255 becomes the half 255. Values outside the half range become infinite, as
+ * IEEE rounding has it.
  *
  * @param {Sampler2D} input
- * @returns {Sampler2D}
+ * @returns {Sampler2D} same shape, `Float16Array` storage
  */
 export function sampler2d_to_f16(input: Sampler2D): Sampler2D;
 import { Sampler2D } from "./Sampler2D.js";

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

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_to_f16.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_f16.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wCAHW,SAAS,GACP,SAAS,CAcrB;0BAnByB,gBAAgB"}
+{"version":3,"file":"sampler2d_to_f16.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_f16.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wCAHW,SAAS,GACP,SAAS,CAgBrB;0BA3ByB,gBAAgB"}

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

@@ -1,21 +1,28 @@
-import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint16.js";
-import { Sampler2D } from "./Sampler2D.js";
-
-/**
- *
- * @param {Sampler2D} input
- * @returns {Sampler2D}
- */
-export function sampler2d_to_f16(input) {
-
-    const data = input.data;
-
-    const dest = Sampler2D.uint16(input.itemSize, input.width, input.height);
-
-    const n = data.length;
-    for (let i = 0; i < n; i++) {
-        dest.data[i] = to_half_float_uint16(data[i]);
-    }
-
-    return  dest;
-}
+import { Sampler2D } from "./Sampler2D.js";
+
+/**
+ * Converts a sampler's values to half precision.
+ *
+ * The result is backed by a `Float16Array`, so it reads back as numbers like any other float sampler,
+ * and its bytes are the binary16 a 16-bit float texture takes. Values are converted as they are, not
+ * normalized: an 8-bit 255 becomes the half 255. Values outside the half range become infinite, as
+ * IEEE rounding has it.
+ *
+ * @param {Sampler2D} input
+ * @returns {Sampler2D} same shape, `Float16Array` storage
+ */
+export function sampler2d_to_f16(input) {
+    const result = Sampler2D.float16(input.itemSize, input.width, input.height);
+
+    const source = input.data;
+    const destination = result.data;
+
+    const n = destination.length;
+
+    for (let i = 0; i < n; i++) {
+        // assignment into a Float16Array rounds to the nearest half
+        destination[i] = source[i];
+    }
+
+    return result;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_to_uint8_RGBA.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.js"],"names":[],"mappings":"AAsCA;;;;GAIG;AACH,mFA6DC"}
+{"version":3,"file":"sampler2d_to_uint8_RGBA.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.js"],"names":[],"mappings":"AAyCA;;;;GAIG;AACH,mFA6DC"}

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

@@ -23,8 +23,11 @@ function compute_gradient_and_intercept_uint8(ctor) {
             gradient = 5.937181414556033e-8;
             intercept = 127;
             break
+        case Float16Array:
         case Float32Array:
         case Float64Array:
+        case Array:
+            // a plain numeric array is float data, the reading sampler2d_compute_texel_value_conversion_scale_to_uint8 takes as well
             gradient = 255;
             break;
         default:

package/src/engine/physics/broadphase/generate_pairs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uIATW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,+CAElF,MAAM,OAAO,MAAM,KAAK,OAAO,oCAyFhD"}
+{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uIATW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,+CAElF,MAAM,OAAO,MAAM,KAAK,OAAO,oCA+FhD"}

package/src/engine/physics/broadphase/generate_pairs.js

@@ -86,9 +86,14 @@ export function generate_pairs(
                     dynamic_bvh,
                     scratch_aabb
                 );
-                if (n <= candidates.length) break;
+
+                if (n <= candidates.length){
+                    break;
+                }
+
                 candidates = new Uint32Array(Math.max(n, candidates.length * 2));
             }
+
             for (let c = 0; c < n; c++) {
                 const other = candidates[c];
                 if (other === my_packed) continue;
@@ -115,6 +120,7 @@ export function generate_pairs(
                 if (n <= candidates.length) break;
                 candidates = new Uint32Array(Math.max(n, candidates.length * 2));
             }
+
             for (let c = 0; c < n; c++) {
                 const other = candidates[c];
 

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#364@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#370@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#364@#clear_field"(fluid: FluidComponent): void;
+    static "__#370@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#364@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#370@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#364@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#370@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];