@woosh/meep-engine 2.74.0 → 2.75.1

package/build/meep.cjs

@@ -53660,6 +53660,12 @@ class TerrainPreview {
     }
 }
 
+/**
+ * equal to `Math.pow(2,32) - 1`
+ * @type {number}
+ */
+const UINT32_MAX = 4294967295;
+
 /**
  * Assumes arrays have the same type
  * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} source
@@ -53739,6 +53745,13 @@ const ELEMENT_WORD_COUNT = 10;
  */
 const INITIAL_CAPACITY = 128;
 
+
+/**
+ * Tree can not contain more than this number of nodes
+ * @type {number}
+ */
+const NODE_CAPACITY_LIMIT = Math.floor(UINT32_MAX / (ELEMENT_WORD_COUNT * 4));
+
 /**
  * Bounding Volume Hierarchy implementation. Stores unsigned integer values at leaves, these are typically IDs or Index values.
  * Highly optimized both in terms of memory usage and CPU. Most of the code inlined. No allocation are performed during usage (except for growing the tree capacity).
@@ -53833,17 +53846,26 @@ class BVH {
     }
 
     __grow_capacity() {
-        const new_capacity = Math.ceil(max2(
+        if (this.__capacity >= NODE_CAPACITY_LIMIT) {
+            throw new Error('Can not grow capacity, already at maximum platform limit');
+        }
+
+        let new_capacity = Math.ceil(max2(
             this.__capacity * CAPACITY_GROW_MULTIPLIER,
             this.__capacity + CAPACITY_GROW_MIN_STEP
         ));
 
+        if (new_capacity > NODE_CAPACITY_LIMIT) {
+            // can not grow as much as we'd like, but we can still grow up to the limit
+            new_capacity = NODE_CAPACITY_LIMIT;
+        }
+
         this.__set_capacity(new_capacity);
     }
 
     /**
      *
-     * @param {number} new_capacity
+     * @param {number} new_capacity in number of nodes
      * @private
      */
     __set_capacity(new_capacity) {
@@ -54395,6 +54417,9 @@ class BVH {
             assert.notEqual(child1, NULL_NODE, 'child1 is null');
             assert.notEqual(child2, NULL_NODE, 'child2 is null');
 
+            assert.notEqual(child1, index, 'child1 is equal to parent');
+            assert.notEqual(child2, index, 'child2 is equal to parent');
+
             this.node_set_combined_aabb(index, child1, child2);
 
             index = uint32[address + COLUMN_PARENT];
@@ -54422,6 +54447,9 @@ class BVH {
             assert.notEqual(child1, NULL_NODE, 'child1 is null');
             assert.notEqual(child2, NULL_NODE, 'child2 is null');
 
+            assert.notEqual(child1, index, 'child1 is equal to parent');
+            assert.notEqual(child2, index, 'child2 is equal to parent');
+
             uint32[node_address + COLUMN_HEIGHT] = 1 + max2(
                 uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
                 uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
@@ -54503,6 +54531,9 @@ class BVH {
         const iB = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
         const iC = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
+        assert.notEqual(iA, iB, 'child1 equal to parent');
+        assert.notEqual(iA, iB, 'child2 equal to parent');
+
         assert.greaterThanOrEqual(iB, 0);
         assert.lessThan(iB, this.node_capacity);
         assert.greaterThanOrEqual(iC, 0);
@@ -54518,6 +54549,9 @@ class BVH {
             const iF = uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
             const iG = uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
+            assert.notEqual(iC, iF, 'child1 equal to parent');
+            assert.notEqual(iC, iG, 'child2 equal to parent');
+
             // b2TreeNode* F = m_nodes + iF;
             // b2TreeNode* G = m_nodes + iG;
 
@@ -54536,6 +54570,7 @@ class BVH {
 
             // A's old parent should point to C
             if (a_parent !== NULL_NODE) {
+                assert.notEqual(a_parent, iC);
                 if (uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === iA) {
                     uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iC;
                 } else {
@@ -54588,6 +54623,9 @@ class BVH {
 
             }
 
+            assert.notEqual(iC, uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_1]);
+            assert.notEqual(iC, uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_2]);
+
             return iC;
         }
 
@@ -54596,6 +54634,9 @@ class BVH {
             const iD = uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
             const iE = uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
+            assert.notEqual(iB, iD, 'child1 equal to parent');
+            assert.notEqual(iB, iE, 'child2 equal to parent');
+
             assert.greaterThanOrEqual(iD, 0);
             assert.lessThan(iD, this.node_capacity);
             assert.greaterThanOrEqual(iE, 0);
@@ -54662,9 +54703,15 @@ class BVH {
 
             }
 
+            assert.notEqual(iB, uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_1]);
+            assert.notEqual(iB, uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_2]);
+
             return iB;
         }
 
+        assert.notEqual(iA, uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_1]);
+        assert.notEqual(iA, uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2]);
+
         // no rotation
         return iA;
     }
@@ -54825,6 +54872,7 @@ const SCRATCH_UINT32_TRAVERSAL_STACK = new Uint32Array(781250);
 
 /**
  * Pointer used to track current top of the stack, make sure to unwind once your traversal is done
+ * Must be a positive integer
  * @type {number}
  */
 SCRATCH_UINT32_TRAVERSAL_STACK.pointer = 0;
@@ -68902,50 +68950,49 @@ function bvh_query_user_data_overlaps_frustum(
     return result_cursor - result_offset;
 }
 
+const PATH_SEPARATOR = '/';
+
 /**
- * @template CTX
- * @template Asset
+ * Strips all directories from the path.
+ * @example 'a/b/c' -> 'c'
+ * @param {string} path
+ * @returns {string}
  */
-class AssetLoader {
-    /**
-     *
-     * @type {AssetManager}
-     */
-    assetManager = null;
+function computePathBase(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
 
-    /**
-     *
-     * @type {CTX}
-     */
-    context = null;
+    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
 
-    /**
-     *
-     * @param {AssetManager} assetManager
-     * @param {CTX} context
-     */
-    async link(assetManager, context) {
-        this.assetManager = assetManager;
-        this.context = context;
+    if (lastSlashIndex !== -1) {
+        return path.substring(lastSlashIndex + 1);
+    } else {
+        return path;
+    }
+}
+
+/**
+ *
+ * @param {string} path
+ * @returns {String|null}
+ */
+function computeFileExtension(path) {
+    const type_of_path = typeof path;
+    if (type_of_path !== "string") {
+        throw new Error(`path must be a string, instead was '${type_of_path}'`);
     }
 
-    /**
-     * Release any held resources, finalizing operation of the loader
-     */
-    async unlink() {
+    //get base
+    const pathBase = computePathBase(path);
 
-    }
+    const lastDotIndex = pathBase.lastIndexOf('.');
 
-    /**
-     *
-     * @param {AssetRequestScope} scope
-     * @param {string} path
-     * @param {function(Asset)} success
-     * @param {function} failure
-     * @param {function(current:number, total:number)} progress
-     */
-    load(scope, path, success, failure, progress) {
-        failure('Not Implemented');
+    if (lastDotIndex !== -1) {
+        return pathBase.substring(lastDotIndex + 1);
+    } else {
+        //no extension
+        return null;
     }
 }
 
@@ -69156,49 +69203,6 @@ class Asset {
 
 Asset.prototype.byteSize = 0;
 
-class ImageRGBADataAsset extends Asset {
-    /**
-     *
-     * @param {number[]|Uint8Array} data
-     * @param {number} width
-     * @param {number} height
-     * @param {number} [itemSize]
-     */
-    constructor(data, width, height, itemSize = 4) {
-        super();
-
-        /**
-         *
-         * @type {number[]}
-         */
-        this.data = data;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.width = width;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.height = height;
-
-        /**
-         * Number of channels
-         * @type {number}
-         */
-        this.itemSize = itemSize;
-
-        this.byteSize = data.length;
-    }
-
-    create() {
-        return new Sampler2D(this.data, this.itemSize, this.width, this.height);
-    }
-}
-
 const CrossOriginKind = {
     UseCredentials: 'use-credentials',
     Anonymous: 'anonymous'
@@ -69214,6 +69218,53 @@ class CrossOriginConfig {
 const default_coc = new CrossOriginConfig();
 CrossOriginConfig.default = Object.freeze(default_coc);
 
+/**
+ * @template CTX
+ * @template Asset
+ */
+class AssetLoader {
+    /**
+     *
+     * @type {AssetManager}
+     */
+    assetManager = null;
+
+    /**
+     *
+     * @type {CTX}
+     */
+    context = null;
+
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @param {CTX} context
+     */
+    async link(assetManager, context) {
+        this.assetManager = assetManager;
+        this.context = context;
+    }
+
+    /**
+     * Release any held resources, finalizing operation of the loader
+     */
+    async unlink() {
+
+    }
+
+    /**
+     *
+     * @param {AssetRequestScope} scope
+     * @param {string} path
+     * @param {function(Asset)} success
+     * @param {function} failure
+     * @param {function(current:number, total:number)} progress
+     */
+    load(scope, path, success, failure, progress) {
+        failure('Not Implemented');
+    }
+}
+
 class ArrayBufferLoader extends AssetLoader {
     /**
      *
@@ -69298,33 +69349,33 @@ class ArrayBufferLoader extends AssetLoader {
             }
 
             const reader = response.body.getReader();
-            response.headers.get('Content-Length');
+            const contentLength = response.headers.get('Content-Length');
+            const total = contentLength ? parseInt(contentLength) : 0;
             let loaded = 0;
 
             // periodically read data into the new stream tracking while download progress
             const stream = new ReadableStream({
+                type: "bytes",
                 start(controller) {
 
-                    readData();
+                    pump();
 
-                    function readData() {
+                    function pump() {
 
                         reader.read().then(({ done, value }) => {
 
                             if (done) {
-
+                                // no more data, we're done
                                 controller.close();
+                                return;
+                            }
 
-                            } else {
-
-                                loaded += value.byteLength;
-
-                                progress(loaded, length);
+                            loaded += value.byteLength;
 
-                                controller.enqueue(value);
-                                readData();
+                            progress(loaded, total);
 
-                            }
+                            controller.enqueue(value);
+                            pump();
 
                         });
 
@@ -69468,6 +69519,10 @@ class OnDemandWorkerManager {
         this.worker = worker;
     }
 
+    /**
+     * In milliseconds
+     * @param {number} v
+     */
     setTimeout(v) {
         assert.isNonNegativeInteger(v, 'v');
 
@@ -69574,7 +69629,7 @@ class ThreadedImageDecoder extends Codec {
          */
         this.worker = new OnDemandWorkerManager(workerBuilder.build());
 
-        this.worker.setTimeout(200);
+        this.worker.setTimeout(1200);
     }
 
     async test(data) {
@@ -69593,104 +69648,46 @@ class ThreadedImageDecoder extends Codec {
     }
 }
 
-/**
- *
- * @param {Image|ImageBitmap|HTMLImageElement} img
- * @returns {Uint8Array}
- */
-function decode(img) {
-    const imgWidth = img.width;
-    const imgHeight = img.height;
-
-    //
-    const canvas = document.createElement('canvas');
-
-    canvas.width = imgWidth;
-    canvas.height = imgHeight;
-
-    const context = canvas.getContext('2d');
-
-    context.drawImage(img, 0, 0, imgWidth, imgHeight);
-
-    const imgd = context.getImageData(0, 0, imgWidth, imgHeight);
-
-    return imgd.data;
-}
-
-class NativeImageDecoder extends Codec {
-    async decode(data) {
-        const image = new Image();
-
-        // convert binary data to image URL that we can load
-        const blob = new Blob([data]);
-        const url = URL.createObjectURL(blob);
-
-        image.src = url;
-
-        // give browser a chance to decode image in async
-        await image.decode();
-
-        const rgba_data = decode(image);
+class ImageRGBADataAsset extends Asset {
+    /**
+     *
+     * @param {number[]|Uint8Array} data
+     * @param {number} width
+     * @param {number} height
+     * @param {number} [itemSize]
+     */
+    constructor(data, width, height, itemSize = 4) {
+        super();
 
-        const width = image.width;
-        const height = image.height;
+        /**
+         *
+         * @type {number[]}
+         */
+        this.data = data;
 
-        // release resources
-        URL.revokeObjectURL(url);
+        /**
+         *
+         * @type {number}
+         */
+        this.width = width;
 
-        return {
-            data: rgba_data,
-            width: width,
-            height: height,
-            itemSize: 4,
-            bitDepth: 8
-        };
-    }
-}
-
-const PATH_SEPARATOR = '/';
-
-/**
- * Strips all directories from the path.
- * @example 'a/b/c' -> 'c'
- * @param {string} path
- * @returns {string}
- */
-function computePathBase(path) {
-    if (typeof path !== "string") {
-        throw new Error('path is not a string');
-    }
+        /**
+         *
+         * @type {number}
+         */
+        this.height = height;
 
-    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+        /**
+         * Number of channels
+         * @type {number}
+         */
+        this.itemSize = itemSize;
 
-    if (lastSlashIndex !== -1) {
-        return path.substring(lastSlashIndex + 1);
-    } else {
-        return path;
-    }
-}
-
-/**
- *
- * @param {string} path
- * @returns {String|null}
- */
-function computeFileExtension(path) {
-    const type_of_path = typeof path;
-    if (type_of_path !== "string") {
-        throw new Error(`path must be a string, instead was '${type_of_path}'`);
+        this.byteSize = data.length;
     }
 
-    //get base
-    const pathBase = computePathBase(path);
-
-    const lastDotIndex = pathBase.lastIndexOf('.');
-
-    if (lastDotIndex !== -1) {
-        return pathBase.substring(lastDotIndex + 1);
-    } else {
-        //no extension
-        return null;
+    create() {
+        return new Sampler2D(this.data, this.itemSize, this.width, this.height);
     }
 }
 
@@ -69702,7 +69699,7 @@ class ImageRGBADataLoader extends AssetLoader {
 
         this.decoder = new CodecWithFallback(
             new ThreadedImageDecoder(),
-            new NativeImageDecoder()
+            // new NativeImageDecoder()
         );
     }
 
@@ -69744,7 +69741,6 @@ class ImageRGBADataLoader extends AssetLoader {
 
         const bitmap = await this.__decode_via_worker(path, scope);
 
-
         let data;
 
         const bitDepth = bitmap.bitDepth;
@@ -69800,30 +69796,37 @@ class ImageRGBADataLoader extends AssetLoader {
 }
 
 /**
- * @author Alex Goldring
- * @copyright Alex Goldring 2018
+ * Utility class for managing connection between listeners to signals
  */
+class SignalBinding {
+    /**
+     * State flag
+     * @type {boolean}
+     */
+    #linked = false;
 
+    get linked() {
+        return this.#linked;
+    }
 
-class SignalBinding {
     /**
      *
      * @param {Signal} signal
      * @param {function} handler
-     * @param {*} [context]
+     * @param {*} [context] will be passed as thisArg to the handler
      * @constructor
      */
     constructor(signal, handler, context) {
         if (typeof handler !== "function") {
-            throw new TypeError(`handler must be a function, instead was ${handler}`);
+            throw new TypeError(`handler must be a function, instead was '${typeof handler}'`);
         }
 
         if (typeof signal !== "object") {
-            throw new TypeError(`signal must be of an object, instead was ${signal}`)
+            throw new TypeError(`signal must be of an object, instead was '${typeof signal}'`)
         }
 
         if (typeof signal.add !== "function") {
-            throw new TypeError(`signal.add must be a function, instead was ${signal.add}`);
+            throw new TypeError(`signal.add must be a function, instead was '${typeof signal.add}'`);
         }
 
         /**
@@ -69844,11 +69847,6 @@ class SignalBinding {
          */
         this.context = context;
 
-        /**
-         * State flag
-         * @type {boolean}
-         */
-        this.linked = false;
     }
 
     /**
@@ -69856,11 +69854,11 @@ class SignalBinding {
      * Idempotent
      */
     link() {
-        if (this.linked) {
+        if (this.#linked) {
             return;
         }
 
-        this.linked = true;
+        this.#linked = true;
         this.signal.add(this.handler, this.context);
     }
 
@@ -69869,11 +69867,11 @@ class SignalBinding {
      * Idempotent
      */
     unlink() {
-        if (!this.linked) {
+        if (!this.#linked) {
             return;
         }
 
-        this.linked = false;
+        this.#linked = false;
         this.signal.remove(this.handler, this.context);
     }
 }
@@ -70353,7 +70351,7 @@ class ObservedBoolean extends Boolean {
 
     /**
      *
-     * @param {function} f
+     * @param {function(boolean)} f
      */
     process(f) {
         f(this.__value);