@woosh/meep-engine 3.14.1 → 3.14.2

package/src/basis/transcode/fit_endpoints.js

@@ -0,0 +1,226 @@
+/**
+ * How many refine-and-reassign rounds to run. The fit converges in two or three for almost every
+ * codebook entry, and the loop leaves early when nothing moves, so this is a ceiling rather than a
+ * cost.
+ *
+ * @readonly
+ * @type {number}
+ */
+const MAX_ITERATIONS = 8;
+
+/**
+ * Every `[min, max]` span of selector values a block can use, as pairs.
+ *
+ * Ten of them, because a span is an ordered pair drawn from four values. A block that only uses the
+ * darkest two colours is fitted against those two alone, which is the whole reason this exists — see
+ * {@link fit_endpoints}.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const SELECTOR_RANGES = [
+    [0, 0], [0, 1], [0, 2], [0, 3],
+    [1, 1], [1, 2], [1, 3],
+    [2, 2], [2, 3],
+    [3, 3],
+];
+
+/**
+ * Which entry of {@link SELECTOR_RANGES} a `[min, max]` span is.
+ *
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function selector_range_index(min, max) {
+    for (let i = 0; i < SELECTOR_RANGES.length; i++) {
+        if (SELECTOR_RANGES[i][0] === min && SELECTOR_RANGES[i][1] === max) {
+            return i;
+        }
+    }
+
+    throw new Error(`Basis: ${min}..${max} is not a selector range`);
+}
+
+/**
+ * Fit a pair of endpoints to the colours a block actually uses, by least squares.
+ *
+ * **Why the obvious choice is not good enough.** An ETC1S block's four colours are its base colour
+ * plus a modifier applied equally to every channel, so before clamping they lie on a line and the
+ * darkest and brightest of them span it exactly. Clamping breaks that. A base colour near white with
+ * a large modifier gives, say, red `{67, 203, 255, 255}` beside green `{0, 0, 57, 193}` — still
+ * ordered, but no longer collinear, because red saturated and green did not. Taking the outer two as
+ * endpoints then leaves the middle two nowhere near the line between them, and no interpolation
+ * weight can recover them.
+ *
+ * So the endpoints are fitted rather than read off: each colour is assigned the weight that suits it
+ * best, the endpoints are re-solved to minimise squared error against all of them at once, and the
+ * two steps alternate.
+ *
+ * **And the fit is over `[min_selector, max_selector]` only.** Which colours a block uses is a
+ * property of its *selector* codebook entry, and most entries do not use all four — a block spanning
+ * only the darkest two is a line those two define exactly, and fitting it against colours it never
+ * samples throws that away for nothing. Conditioning on the span is what closes most of the distance
+ * to the reference transcoder on saturated content.
+ *
+ * @param {Uint8Array} low three channels, seeded with a guess and overwritten with the fit
+ * @param {Uint8Array} high three channels, likewise
+ * @param {Uint8Array} colors twelve bytes, the block's four `[r, g, b]` colours
+ * @param {Int32Array} weights the destination format's interpolation weights, out of 64
+ * @param {number} min_selector lowest selector value any block using this pairing has
+ * @param {number} max_selector highest
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function fit_endpoints(low, high, colors, weights, min_selector, max_selector) {
+    if (min_selector === max_selector) {
+        /*
+         One colour, and both endpoints are it — every weight then interpolates to the same value, so
+         there is nothing to solve and the normal equations below would be singular anyway.
+        */
+        for (let c = 0; c < 3; c++) {
+            low[c] = colors[min_selector * 3 + c];
+            high[c] = colors[min_selector * 3 + c];
+        }
+
+        return;
+    }
+
+    const assigned = new Int32Array(4);
+
+    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+        for (let selector = min_selector; selector <= max_selector; selector++) {
+            assigned[selector] = nearest_weight(low, high, weights, colors, selector * 3);
+        }
+
+        let sum_aa = 0;
+        let sum_ab = 0;
+        let sum_bb = 0;
+
+        for (let selector = min_selector; selector <= max_selector; selector++) {
+            const b = weights[assigned[selector]] / 64;
+            const a = 1 - b;
+
+            sum_aa += a * a;
+            sum_ab += a * b;
+            sum_bb += b * b;
+        }
+
+        const determinant = sum_aa * sum_bb - sum_ab * sum_ab;
+
+        // singular when every colour in the span was assigned the same weight; the fit is done
+        if (Math.abs(determinant) < 1e-6) {
+            return;
+        }
+
+        let moved = false;
+
+        for (let c = 0; c < 3; c++) {
+            let sum_ap = 0;
+            let sum_bp = 0;
+
+            for (let selector = min_selector; selector <= max_selector; selector++) {
+                const b = weights[assigned[selector]] / 64;
+                const a = 1 - b;
+                const p = colors[selector * 3 + c];
+
+                sum_ap += a * p;
+                sum_bp += b * p;
+            }
+
+            const solved_low = (sum_bb * sum_ap - sum_ab * sum_bp) / determinant;
+            const solved_high = (sum_aa * sum_bp - sum_ab * sum_ap) / determinant;
+
+            const next_low = clamp_round(solved_low);
+            const next_high = clamp_round(solved_high);
+
+            if (next_low !== low[c] || next_high !== high[c]) {
+                moved = true;
+            }
+
+            low[c] = next_low;
+            high[c] = next_high;
+        }
+
+        if (!moved) {
+            return;
+        }
+    }
+}
+
+/**
+ * @param {number} value
+ * @returns {number} rounded into `[0, 255]`
+ */
+function clamp_round(value) {
+    const rounded = Math.round(value);
+
+    return rounded < 0 ? 0 : rounded > 255 ? 255 : rounded;
+}
+
+/**
+ * Which weight puts the interpolated colour closest to a target.
+ *
+ * @param {Uint8Array} low three channels
+ * @param {Uint8Array} high three channels
+ * @param {Int32Array} weights
+ * @param {Uint8Array} target
+ * @param {number} target_offset
+ * @returns {number} an index into `weights`
+ */
+function nearest_weight(low, high, weights, target, target_offset) {
+    let best = 0;
+    let best_error = Infinity;
+
+    for (let i = 0; i < weights.length; i++) {
+        const weight = weights[i];
+
+        let error = 0;
+
+        for (let c = 0; c < 3; c++) {
+            const interpolated = (low[c] * (64 - weight) + high[c] * weight + 32) >> 6;
+            const delta = interpolated - target[target_offset + c];
+
+            error += delta * delta;
+        }
+
+        if (error < best_error) {
+            best_error = error;
+            best = i;
+        }
+    }
+
+    return best;
+}
+
+/**
+ * The `[min, max]` selector span of every entry of a selector codebook.
+ *
+ * @param {Etc1sSelectorCodebook} selectors
+ * @returns {Uint8Array} one index into {@link SELECTOR_RANGES} per entry
+ */
+export function selector_codebook_ranges(selectors) {
+    const out = new Uint8Array(selectors.count);
+
+    for (let entry = 0; entry < selectors.count; entry++) {
+        let min = 3;
+        let max = 0;
+
+        for (let i = 0; i < 16; i++) {
+            const selector = selectors.selectors[entry * 16 + i];
+
+            if (selector < min) {
+                min = selector;
+            }
+
+            if (selector > max) {
+                max = selector;
+            }
+        }
+
+        out[entry] = selector_range_index(min, max);
+    }
+
+    return out;
+}

package/src/{avif/native/isobmff → core/binary}/ByteCursor.d.ts

@@ -1,15 +1,20 @@
 /**
- * Big-endian byte cursor over an `ArrayBuffer`, bounds-checked on every read.
+ * Byte cursor over an `ArrayBuffer`, bounds-checked on every read.
  *
- * ISOBMFF parsing wants cheap random access into a buffer that already exists — box sizes point
- * forwards, item offsets point anywhere — and it never wants a copy. `core/binary/BinaryBuffer.js`
- * is a growable stream built for the opposite job; using it here would mean carrying its growth
+ * Container parsing wants cheap random access into a buffer that already exists — box sizes point
+ * forwards, level offsets point backwards — and it never wants a copy. {@link BinaryBuffer} is a
+ * growable stream built for the opposite job; using it here would mean carrying its growth
  * machinery through a parser that never grows anything. This is the read half; writing goes through
- * {@link BoxWriter}, which does use `BinaryBuffer`.
+ * `BinaryBuffer`, which is the right shape for it.
  *
  * Every accessor validates against {@link end} before touching memory. A truncated or hostile file
  * must throw a named error, not read whatever happens to follow in the buffer.
  *
+ * **Endianness is stated by the caller, once**, because it is a property of the *container* rather
+ * than of any one field: ISOBMFF is big-endian throughout, KTX2 is little-endian throughout, and a
+ * parser that had to name the order at every call site would eventually name one of them wrong.
+ * {@link u8}, {@link fourcc} and {@link view_bytes} are order-free and read the same either way.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -32,13 +37,20 @@ export class ByteCursor {
      * @type {number}
      */
     end: number;
+    /**
+     * Byte order of every multi-byte read. Stated at {@link init}, never guessed.
+     * @type {EndianType|boolean}
+     */
+    endianness: EndianType | boolean;
     /**
      * @param {ArrayBuffer|Uint8Array} source
+     * @param {EndianType|boolean} endianness byte order of the container being read. Required — a
+     * cursor that guessed would read a plausible wrong number rather than fail
      * @param {number} [byte_offset]
      * @param {number} [byte_length]
      * @returns {ByteCursor} this
      */
-    init(source: ArrayBuffer | Uint8Array, byte_offset?: number, byte_length?: number): ByteCursor;
+    init(source: ArrayBuffer | Uint8Array, endianness: EndianType | boolean, byte_offset?: number, byte_length?: number): ByteCursor;
     /**
      * Create an independent cursor over a sub-range of this one, sharing the same memory.
      * @param {number} byte_offset absolute offset
@@ -122,4 +134,5 @@ export class ByteCursor {
      */
     seek(position: number): void;
 }
+import { EndianType } from "./EndianType.js";
 //# sourceMappingURL=ByteCursor.d.ts.map

package/src/core/binary/ByteCursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ByteCursor.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/ByteCursor.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI;;OAEG;IACH,MAFU,QAAQ,CAEN;IAEZ;;OAEG;IACH,OAFU,UAAU,CAEP;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,KAFU,MAAM,CAER;IAER;;;OAGG;IACH,YAFU,UAAU,GAAC,OAAO,CAEM;IAElC;;;;;;;OAOG;IACH,aAPW,WAAW,GAAC,UAAU,cACtB,UAAU,GAAC,OAAO,gBAElB,MAAM,gBACN,MAAM,GACJ,UAAU,CAsBtB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,eACN,MAAM,GACJ,UAAU,CAgBtB;IAED;;OAEG;IACH,wBAEC;IAED;;;OAGG;IACH,eAHW,MAAM,QACN,MAAM,QAMhB;IAED;;OAEG;IACH,MAFa,MAAM,CAMlB;IAED;;OAEG;IACH,OAFa,MAAM,CAUlB;IAED;;OAEG;IACH,OAFa,MAAM,CAiBlB;IAED;;OAEG;IACH,OAFa,MAAM,CAUlB;IAED;;OAEG;IACH,OAFa,MAAM,CAUlB;IAED;;OAEG;IACH,OAFa,MAAM,CAUlB;IAED;;;;;;;OAOG;IACH,OAFa,MAAM,CAiBlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;OAGG;IACH,UAFa,MAAM,CAUlB;IAED;;;;OAIG;IACH,eAFa,MAAM,CAgBlB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,UAAU,CAUtB;IAED;;OAEG;IACH,YAFW,MAAM,QAMhB;IAED;;OAEG;IACH,eAFW,MAAM,QAQhB;CACJ;2BAnU0B,iBAAiB"}

package/src/{avif/native/isobmff → core/binary}/ByteCursor.js

@@ -1,17 +1,24 @@
-import { utf8_decode } from "../../../core/binary/utf8/utf8_decode.js";
+import { assert } from "../assert.js";
+import { EndianType } from "./EndianType.js";
+import { utf8_decode } from "./utf8/utf8_decode.js";
 
 /**
- * Big-endian byte cursor over an `ArrayBuffer`, bounds-checked on every read.
+ * Byte cursor over an `ArrayBuffer`, bounds-checked on every read.
  *
- * ISOBMFF parsing wants cheap random access into a buffer that already exists — box sizes point
- * forwards, item offsets point anywhere — and it never wants a copy. `core/binary/BinaryBuffer.js`
- * is a growable stream built for the opposite job; using it here would mean carrying its growth
+ * Container parsing wants cheap random access into a buffer that already exists — box sizes point
+ * forwards, level offsets point backwards — and it never wants a copy. {@link BinaryBuffer} is a
+ * growable stream built for the opposite job; using it here would mean carrying its growth
  * machinery through a parser that never grows anything. This is the read half; writing goes through
- * {@link BoxWriter}, which does use `BinaryBuffer`.
+ * `BinaryBuffer`, which is the right shape for it.
  *
  * Every accessor validates against {@link end} before touching memory. A truncated or hostile file
  * must throw a named error, not read whatever happens to follow in the buffer.
  *
+ * **Endianness is stated by the caller, once**, because it is a property of the *container* rather
+ * than of any one field: ISOBMFF is big-endian throughout, KTX2 is little-endian throughout, and a
+ * parser that had to name the order at every call site would eventually name one of them wrong.
+ * {@link u8}, {@link fourcc} and {@link view_bytes} are order-free and read the same either way.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -38,13 +45,23 @@ export class ByteCursor {
      */
     end = 0;
 
+    /**
+     * Byte order of every multi-byte read. Stated at {@link init}, never guessed.
+     * @type {EndianType|boolean}
+     */
+    endianness = EndianType.BigEndian;
+
     /**
      * @param {ArrayBuffer|Uint8Array} source
+     * @param {EndianType|boolean} endianness byte order of the container being read. Required — a
+     * cursor that guessed would read a plausible wrong number rather than fail
      * @param {number} [byte_offset]
      * @param {number} [byte_length]
      * @returns {ByteCursor} this
      */
-    init(source, byte_offset = 0, byte_length = -1) {
+    init(source, endianness, byte_offset = 0, byte_length = -1) {
+        assert.isBoolean(endianness, 'endianness');
+
         const buffer = source instanceof Uint8Array ? source.buffer : source;
         const base = source instanceof Uint8Array ? source.byteOffset : 0;
         const available = source instanceof Uint8Array ? source.byteLength : source.byteLength;
@@ -59,6 +76,7 @@ export class ByteCursor {
         this.bytes = new Uint8Array(buffer, base, available);
         this.position = byte_offset;
         this.end = byte_offset + length;
+        this.endianness = endianness;
 
         return this;
     }
@@ -80,6 +98,7 @@ export class ByteCursor {
         cursor.bytes = this.bytes;
         cursor.position = byte_offset;
         cursor.end = byte_offset + byte_length;
+        cursor.endianness = this.endianness;
 
         return cursor;
     }
@@ -116,7 +135,7 @@ export class ByteCursor {
     u16() {
         this.require(2, "uint16");
 
-        const value = this.view.getUint16(this.position, false);
+        const value = this.view.getUint16(this.position, this.endianness);
 
         this.position += 2;
 
@@ -130,7 +149,13 @@ export class ByteCursor {
         this.require(3, "uint24");
 
         const p = this.position;
-        const value = (this.bytes[p] << 16) | (this.bytes[p + 1] << 8) | this.bytes[p + 2];
+        const b0 = this.bytes[p];
+        const b1 = this.bytes[p + 1];
+        const b2 = this.bytes[p + 2];
+
+        const value = this.endianness === EndianType.LittleEndian
+            ? (b2 << 16) | (b1 << 8) | b0
+            : (b0 << 16) | (b1 << 8) | b2;
 
         this.position += 3;
 
@@ -143,7 +168,7 @@ export class ByteCursor {
     u32() {
         this.require(4, "uint32");
 
-        const value = this.view.getUint32(this.position, false);
+        const value = this.view.getUint32(this.position, this.endianness);
 
         this.position += 4;
 
@@ -156,7 +181,7 @@ export class ByteCursor {
     i16() {
         this.require(2, "int16");
 
-        const value = this.view.getInt16(this.position, false);
+        const value = this.view.getInt16(this.position, this.endianness);
 
         this.position += 2;
 
@@ -169,7 +194,7 @@ export class ByteCursor {
     i32() {
         this.require(4, "int32");
 
-        const value = this.view.getInt32(this.position, false);
+        const value = this.view.getInt32(this.position, this.endianness);
 
         this.position += 4;
 
@@ -187,8 +212,10 @@ export class ByteCursor {
     u64() {
         this.require(8, "uint64");
 
-        const high = this.view.getUint32(this.position, false);
-        const low = this.view.getUint32(this.position + 4, false);
+        const little = this.endianness === EndianType.LittleEndian;
+
+        const high = this.view.getUint32(this.position + (little ? 4 : 0), little);
+        const low = this.view.getUint32(this.position + (little ? 0 : 4), little);
 
         this.position += 8;
 

package/src/engine/EngineHarness.js

@@ -234,7 +234,7 @@ export class EngineHarness {
             yaw = 0,
             autoClip = true,
             distanceMin = 0.01,
-            distanceMax = 1000,
+            distanceMax = 300,
             fieldOfView = 45
         }
     ) {

package/src/engine/asset/codec/Codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Codec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/codec/Codec.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;IACI;;;;OAIG;IACH,aAHW,UAAU,GACR,QAAQ,CAAC,CAAC,CAKtB;IAED;;;;OAIG;IACH,WAHW,UAAU,GACT,QAAQ,OAAO,CAAC,CAI3B;CACJ"}

package/src/engine/asset/codec/CodecWithFallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodecWithFallback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/codec/CodecWithFallback.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IAOI;;;OAGG;IACH,uBAFW,MAAM,CAAC,CAAC,EAclB;IAtBD;;;OAGG;IACH,UAFU,MAAM,CAAC,CAAC,EAAE,CAEP;IAgCb,kCAeC;IAED,8BAuCC;;CACJ;sBAtGqB,YAAY"}

package/src/engine/asset/{loaders/image/codec → codec}/CodecWithFallback.js

@@ -1,5 +1,5 @@
-import { assert } from "../../../../../core/assert.js";
-import { array_push_if_unique } from "../../../../../core/collection/array/array_push_if_unique.js";
+import { assert } from "../../../core/assert.js";
+import { array_push_if_unique } from "../../../core/collection/array/array_push_if_unique.js";
 import { Codec } from "./Codec.js";
 
 /**

package/src/engine/asset/loaders/image/IMAGE_CODEC_REVIEW_2026_08_28.md

@@ -28,7 +28,7 @@ drifts.
 reimplement, badly and privately, things AVIF already has generalised — channel expansion to RGBA,
 YCbCr conversion, chroma upsampling, chunk walking, bounds checking. The single most valuable move
 in this document is not a merge: it is **registering AVIF and JPEG behind the `Codec` interface that
-already exists** ([Codec.js](codec/Codec.js)) so that all three formats reach the engine through one
+already exists** ([Codec.js](../../codec/Codec.js)) so that all three formats reach the engine through one
 door with one result shape. Today PNG goes through a worker, JPEG goes nowhere at all, and AVIF
 bypasses the asset-loader system entirely via `avif_to_sampler2d`.
 
@@ -106,7 +106,7 @@ browser canvas path — which is why the native JPEG decoder has never needed to
    [JpegImage.js:139](jpeg/JpegImage.js#L139), and `ftyp`/`meta` presence at
    [parse_avif_file.js:51](../../../../avif/native/heif/parse_avif_file.js#L51). Give each format a
    `*_HEADER_BYTES` (or a `test` predicate) beside its decoder and have the codec use it.
-3. `CodecWithFallback` ([CodecWithFallback.js:11](codec/CodecWithFallback.js#L11)) already does
+3. `CodecWithFallback` ([CodecWithFallback.js:11](../../codec/CodecWithFallback.js#L11)) already does
    ordered try-with-sniff correctly. Compose `[Threaded(PNG), Jpeg, Avif, Native]` and the format
    switch disappears from `ImageRGBADataLoader` and from `ImageDecoderWorker`.
 4. `avif_to_sampler2d` stays — it is the HDR-aware adapter and the exact inverse of
@@ -273,7 +273,7 @@ struct, visitor returns `false`, walker guarantees forward progress — so that
 
 ### C6 — Bounds checking exists on one side of the fence only
 
-`ByteCursor.require(count, what)` ([ByteCursor.js:96](../../../../avif/native/isobmff/ByteCursor.js#L96))
+`ByteCursor.require(count, what)` ([ByteCursor.js:96](../../../../core/binary/ByteCursor.js#L96))
 validates every read and names the field in the error. `BitReader` does the same for every
 descriptor. There is a `robustness.spec.js` that feeds the decoder truncated and hostile files.
 
@@ -327,7 +327,7 @@ records choices like this in `DECISIONS.md`. Give the PNG folder the same treatm
 
 ### C8 — NUL-terminated UTF-8, encoded and decoded privately in two places
 
-[ByteCursor.js:307](../../../../avif/native/isobmff/ByteCursor.js#L307) has a private `utf8_decode`
+[ByteCursor.js:307](../../../../core/binary/ByteCursor.js#L307) has a private `utf8_decode`
 with the stated reason that `TextDecoder` is not universally available.
 [BoxWriter.js:205](../../../../avif/native/isobmff/BoxWriter.js#L205) has the matching encoder inline
 in `utf8_string`. `BinaryBuffer` has `readUTF8String` / `writeUTF8String` but they are

package/src/engine/asset/loaders/image/ImageRGBADataLoader.d.ts

@@ -35,5 +35,5 @@ export class ImageRGBADataLoader extends AssetLoader<any, any> {
     load(scope: any, path: any, success: any, failure: any, progress: any): Promise<void>;
 }
 import { AssetLoader } from "../AssetLoader.js";
-import { CodecWithFallback } from "./codec/CodecWithFallback.js";
+import { CodecWithFallback } from "../../codec/CodecWithFallback.js";
 //# sourceMappingURL=ImageRGBADataLoader.d.ts.map

package/src/engine/asset/loaders/image/ImageRGBADataLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageRGBADataLoader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/image/ImageRGBADataLoader.js"],"names":[],"mappings":"AASA;IACI;;;OAGG;IACH,8BAFW,MAAM,EAehB;IARG;;;OAGG;IACH,SAFU,kBAAkB;QAAC,IAAI,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAA;KAAC,CAAC,CAKjG;IAGL,oDAOC;IAED;;;;;;OAMG;IACH,4BASC;IAED;;;;;;OAMG;IACH,mBAyBC;IAED,sFAEC;CACJ;4BA5F2B,mBAAmB;kCACb,8BAA8B"}
+{"version":3,"file":"ImageRGBADataLoader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/image/ImageRGBADataLoader.js"],"names":[],"mappings":"AASA;IACI;;;OAGG;IACH,8BAFW,MAAM,EAehB;IARG;;;OAGG;IACH,SAFU,kBAAkB;QAAC,IAAI,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAA;KAAC,CAAC,CAKjG;IAGL,oDAOC;IAED;;;;;;OAMG;IACH,4BASC;IAED;;;;;;OAMG;IACH,mBAyBC;IAED,sFAEC;CACJ;4BA5F2B,mBAAmB;kCACb,kCAAkC"}

package/src/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -1,6 +1,6 @@
 import { ArrayBufferLoader } from "../ArrayBufferLoader.js";
 import { AssetLoader } from "../AssetLoader.js";
-import { CodecWithFallback } from "./codec/CodecWithFallback.js";
+import { CodecWithFallback } from "../../codec/CodecWithFallback.js";
 import { NativeImageDecoder } from "./codec/NativeImageDecoder.js";
 import { ThreadedImageDecoder } from "./codec/ThreadedImageDecoder.js";
 import { ImageRGBADataAsset } from "./ImageRGBADataAsset.js";

package/src/engine/asset/loaders/image/codec/NativeImageDecoder.d.ts

@@ -30,5 +30,5 @@ export class NativeImageDecoder extends Codec<{
         bitDepth: number;
     }>;
 }
-import { Codec } from "./Codec.js";
+import { Codec } from "../../../codec/Codec.js";
 //# sourceMappingURL=NativeImageDecoder.d.ts.map

package/src/engine/asset/loaders/image/codec/NativeImageDecoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/NativeImageDecoder.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH;WAF0B,MAAM;YAAS,MAAM;UAAQ,UAAU;cAAY,MAAM;cAAW,MAAM;;;IAGhG;;;;OAIG;IACH,iBAHW,UAAU,GACT;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAgBhG;IAED;;;;;;OAiBC;CACJ;sBAxGqB,YAAY"}
+{"version":3,"file":"NativeImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/NativeImageDecoder.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH;WAF0B,MAAM;YAAS,MAAM;UAAQ,UAAU;cAAY,MAAM;cAAW,MAAM;;;IAGhG;;;;OAIG;IACH,iBAHW,UAAU,GACT;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAgBhG;IAED;;;;;;OAiBC;CACJ;sBAxGqB,yBAAyB"}

package/src/engine/asset/loaders/image/codec/NativeImageDecoder.js

@@ -1,4 +1,4 @@
-import { Codec } from "./Codec.js";
+import { Codec } from "../../../codec/Codec.js";
 
 /**
  *

package/src/engine/asset/loaders/image/codec/ThreadedImageDecoder.d.ts

@@ -12,6 +12,6 @@ export class ThreadedImageDecoder extends Codec<any> {
     test(data: any): Promise<boolean>;
     decode(data: any): Promise<any>;
 }
-import { Codec } from "./Codec.js";
+import { Codec } from "../../../codec/Codec.js";
 import { OnDemandWorkerManager } from "../../../../../core/process/worker/OnDemandWorkerManager.js";
 //# sourceMappingURL=ThreadedImageDecoder.d.ts.map

package/src/engine/asset/loaders/image/codec/ThreadedImageDecoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThreadedImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/ThreadedImageDecoder.js"],"names":[],"mappings":"AAMA;IACI;;;OAGG;IACH,8BAFW,MAAM,EAwBhB;IARG;;;OAGG;IACH,QAFU,qBAAqB,CAE+B;IAMlE,kCAaC;IAED,gCAEC;CACJ;sBAjDqB,YAAY;sCAHI,6DAA6D"}
+{"version":3,"file":"ThreadedImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/ThreadedImageDecoder.js"],"names":[],"mappings":"AAMA;IACI;;;OAGG;IACH,8BAFW,MAAM,EAwBhB;IARG;;;OAGG;IACH,QAFU,qBAAqB,CAE+B;IAMlE,kCAaC;IAED,gCAEC;CACJ;sBAjDqB,yBAAyB;sCAHT,6DAA6D"}

package/src/engine/asset/loaders/image/codec/ThreadedImageDecoder.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../../core/assert.js";
 import { OnDemandWorkerManager } from "../../../../../core/process/worker/OnDemandWorkerManager.js";
 import WorkerBuilder from "../../../../../core/process/worker/WorkerBuilder.js";
 import { PNG_HEADER_BYTES } from "../png/PNG_HEADER_BYTES.js";
-import { Codec } from "./Codec.js";
+import { Codec } from "../../../codec/Codec.js";
 
 export class ThreadedImageDecoder extends Codec {
     /**

package/src/engine/graphics/texture/atlas/TextureAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAkBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cA6BC;IAsDD;;OAEG;IACH,cAQC;CACJ;qCAxjBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}
+{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAqBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cAsCC;IAsDD;;OAEG;IACH,cASC;CACJ;qCArkBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}

package/src/engine/graphics/texture/atlas/TextureAtlas.js

@@ -147,6 +147,9 @@ export class TextureAtlas extends AbstractTextureAtlas {
         //erase data
         this.__sampler.data.fill(0);
 
+        // written through `data` rather than through the sampler, so the version is moved by hand
+        this.__sampler.version++;
+
         this.__needsUpdate = true;
     }
 
@@ -511,6 +514,15 @@ export class TextureAtlas extends AbstractTextureAtlas {
         // console.timeEnd('TextureAtlas.paint');
 
         if (paintCount > 0) {
+            /*
+             The atlas's own pixels have changed, and everything that mirrors them -- a GPU texture,
+             a debug canvas -- decides whether to re-read by comparing this version. The bump belongs
+             here rather than in `paintPatch`, because that is the method subclasses override: one
+             that paints into `data` itself, as `DecalAtlas` does for its borders, never reaches the
+             copy helper that would otherwise have moved the version for it.
+            */
+            this.__sampler.version++;
+
             //notify that atlas was painted
             this.on.painted.send0();
         }
@@ -573,6 +585,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
      */
     reset() {
         this.__sampler.data.fill(0);
+        this.__sampler.version++;
 
         this.patches = [];
 

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 "__#368@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#364@#clear_field"(fluid: FluidComponent): void;
+    static "__#368@#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 "__#368@#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 "__#368@#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>)[];