@woosh/meep-engine 2.114.0 → 2.116.0

package/build/meep.cjs

@@ -47415,7 +47415,7 @@ class Vector2 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     fromArray(array, offset = 0) {
@@ -47427,7 +47427,7 @@ class Vector2 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     toArray(array, offset = 0) {
@@ -49003,6 +49003,34 @@ function compute_typed_array_constructor_from_data_type(dt) {
     return r;
 }
 
+/**
+ * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
+ * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} stride
+ * @return {number}
+ */
+function computeStridedIntegerArrayHash(
+    array, offset, length, stride
+) {
+    let hash = length;
+
+    for (let i = offset; i < length; i += stride) {
+        const value = array[i] >>> 0; //force uint32
+
+        /**
+         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
+         * (h<<5) - h ===  h*31
+         * @type {number}
+         */
+        hash = ((hash << 5) - hash) + value;
+    }
+
+    // force uint32
+    return hash >>> 0;
+}
+
 /**
  *
  * @param {*} array
@@ -49128,47 +49156,6 @@ function is_typed_array_equals(a, b) {
     return isArrayEqualStrict(a_proxy, b_proxy);
 }
 
-/**
- * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
- * @param {number} t ratio
- * @param {number} a position -2
- * @param {number} b position -1
- * @param {number} c position +1
- * @param {number} d position +2
- * @returns {number}
- */
-function interpolate_bicubic(t, a, b, c, d) {
-    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
-}
-
-/**
- * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
- * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
- * @param {number} offset
- * @param {number} length
- * @param {number} stride
- * @return {number}
- */
-function computeStridedIntegerArrayHash(
-    array, offset, length, stride
-) {
-    let hash = length;
-
-    for (let i = offset; i < length; i += stride) {
-        const value = array[i] >>> 0; //force uint32
-
-        /**
-         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
-         * (h<<5) - h ===  h*31
-         * @type {number}
-         */
-        hash = ((hash << 5) - hash) + value;
-    }
-
-    // force uint32
-    return hash >>> 0;
-}
-
 function typedArrayConstructorByInstance(a) {
     if (a instanceof Int8Array) {
         return Int8Array;
@@ -49195,6 +49182,19 @@ function typedArrayConstructorByInstance(a) {
     }
 }
 
+/**
+ * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
+ * @param {number} t ratio
+ * @param {number} a position -2
+ * @param {number} b position -1
+ * @param {number} c position +1
+ * @param {number} d position +2
+ * @returns {number}
+ */
+function interpolate_bicubic(t, a, b, c, d) {
+    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
+}
+
 /**
  * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
  * Inspired by OpenGL's glsl sampler2d API
@@ -54444,7 +54444,10 @@ function overlap1D(a0, a1, b0, b1) {
  * @param {number} by1
  * @returns {boolean} true if overlap exists, false if no overlap
  */
-function aabb2_overlap_exists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1) {
+function aabb2_overlap_exists(
+    ax0, ay0, ax1, ay1,
+    bx0, by0, bx1, by1
+) {
     return overlap1D(ax0, ax1, bx0, bx1)
         && overlap1D(ay0, ay1, by0, by1);
 }
@@ -59312,7 +59315,7 @@ function computeThreeTextureInternalFormatFromDataType(dt, channel_count) {
  * @param {Sampler2D} sampler
  * @returns {DataTexture}
  */
-function sampler2DtoFloat32Texture(sampler) {
+function sampler2d_to_float32_texture(sampler) {
 
     const width = sampler.width;
     const height = sampler.height;
@@ -59385,7 +59388,7 @@ function heightMap2NormalMap(renderer, sampler) {
     const width = sampler.width;
     const height = sampler.height;
 
-    const texture = sampler2DtoFloat32Texture(sampler);
+    const texture = sampler2d_to_float32_texture(sampler);
 
     //construct shader
     const shader = new NormalMapShader();
@@ -59688,9 +59691,9 @@ function normalMap2OcclusionMap(
     const width = resultSize.x;
     const height = resultSize.y;
     //
-    const normalTexture = sampler2DtoFloat32Texture(normalMap);
+    const normalTexture = sampler2d_to_float32_texture(normalMap);
 
-    const heightTexture = sampler2DtoFloat32Texture(heightMap);
+    const heightTexture = sampler2d_to_float32_texture(heightMap);
 
 
     //construct shader
@@ -61406,7 +61409,7 @@ function objectsEqual(a, b) {
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-function arrayIndexByEquality(array, element, equals) {
+function array_index_by_equality(array, element, equals) {
     const n = array.length;
 
     for (let i = 0; i < n; i++) {
@@ -61422,14 +61425,14 @@ function arrayIndexByEquality(array, element, equals) {
 
 /**
  * Compute a diff between two arrays, result is a 3 way split between common items, unique items in `a` array and unique items in `b` array
- * @see prefer to use {@link arraySetSortingDiff}, as it's much faster, especially for large sets
+ * @see prefer to use {@link array_set_diff_sorting}, as it's much faster, especially for large sets
  * @template T
  * @param {T[]} a
  * @param {T[]} b
  * @param {function(a:T,b:T):boolean} [equals] method to determine equality between two elements
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-function arraySetDiff(a, b, equals = strictEquals) {
+function array_set_diff(a, b, equals = strictEquals) {
 
     const uniqueA = a.slice();
     const uniqueB = b.slice();
@@ -61441,7 +61444,7 @@ function arraySetDiff(a, b, equals = strictEquals) {
     for (let i = 0; i < a_length; i++) {
         const elA = uniqueA[i];
 
-        const j = arrayIndexByEquality(uniqueB, elA, equals);
+        const j = array_index_by_equality(uniqueB, elA, equals);
 
         if (j !== -1) {
             // common element found
@@ -61666,7 +61669,7 @@ class List {
 
         const data = this.data;
 
-        const diff = arraySetDiff(data, new_data, objectsEqual);
+        const diff = array_set_diff(data, new_data, objectsEqual);
 
         //resolve diff
         const removals = diff.uniqueA;
@@ -62185,7 +62188,7 @@ class List {
         for (let i = 0; i < nThisItems; i++) {
             const a = thisItems[i];
 
-            const index = arrayIndexByEquality(otherItems, a, invokeObjectEquals);
+            const index = array_index_by_equality(otherItems, a, invokeObjectEquals);
 
             if (index !== -1) {
                 newData[index] = a;
@@ -87420,7 +87423,7 @@ class RingBuffer {
     }
 
     /**
-     *
+     * Removed first element that fulfills the criteria
      * @param {function(V):boolean} condition
      * @param {*} [thisArg]
      * @returns {V|undefined}
@@ -94306,7 +94309,7 @@ class EntityComponentDataset {
 
         const newComponentTypeCount = map.length;
 
-        const diff = arraySetDiff(map, this.componentTypeMap);
+        const diff = array_set_diff(map, this.componentTypeMap);
 
         const typesToAdd = diff.uniqueA;
         const typesToRemove = diff.uniqueB;
@@ -94524,7 +94527,7 @@ class EntityComponentDataset {
      * @returns {boolean} false if no new classes were added, true if at least one new class was added
      */
     registerManyComponentTypes(types) {
-        const diff = arraySetDiff(types, this.componentTypeMap);
+        const diff = array_set_diff(types, this.componentTypeMap);
 
         if (diff.uniqueA.length === 0) {
             // all classes area already registered
@@ -99189,6 +99192,30 @@ function intersects1D(a0, a1, b0, b1) {
     return a1 >= b0 && b1 >= a0;
 }
 
+/**
+ *
+ * @param {number} bounds_x0
+ * @param {number} bounds_y0
+ * @param {number} bounds_x1
+ * @param {number} bounds_y1
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {boolean}
+ */
+function aabb2_contains(
+    bounds_x0, bounds_y0, bounds_x1, bounds_y1,
+    x0, y0, x1, y1
+) {
+
+    return x0 >= bounds_x0
+        && x1 <= bounds_x1
+        && y0 >= bounds_y0
+        && y1 <= bounds_y1
+        ;
+}
+
 class Rectangle {
     /**
      *
@@ -99325,8 +99352,13 @@ class Rectangle {
 
         const _x0 = p.x;
         const _y0 = p.y;
+        const _x1 = s.x + _x0;
+        const _y1 = _y0 + s.y;
 
-        return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
+        return aabb2_overlap_exists(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -99339,6 +99371,7 @@ class Rectangle {
         const y0 = other.position.y;
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
+
         return this._overlaps(x0, y0, x1, y1);
     }
 
@@ -99398,13 +99431,18 @@ class Rectangle {
     _contains(x0, y0, x1, y1) {
         const size = this.size;
 
-        const _x0 = this.position.x;
-        const _y0 = this.position.y;
+        const position = this.position;
+
+        const _x0 = position.x;
+        const _y0 = position.y;
 
         const _y1 = size.y + _y0;
         const _x1 = size.x + _x0;
 
-        return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
+        return aabb2_contains(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -99415,6 +99453,7 @@ class Rectangle {
     contains(other) {
         const x0 = other.position.x;
         const y0 = other.position.y;
+
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
 
@@ -115450,43 +115489,138 @@ function getURLHash() {
     return result;
 }
 
-class EnginePlatform {
-    /**
-     * @returns {Storage}
-     */
-    getStorage() {
-        throw new Error('Not implemented');
+/**
+ * Picks element with highest score from the array using supplied scoring function.
+ * If multiple elements with the same highest score exist, the result will be first such encountered element
+ * @template T
+ * @param {T[]} array
+ * @param {function(el:T, index:number):number} scoreFunction
+ * @returns {T|undefined}
+ */
+function array_pick_best_element(array, scoreFunction) {
+
+    let bestElement;
+    let bestScore;
+
+    const size = array.length;
+
+    if (size === 0) {
+        return undefined;
     }
 
-    /**
-     * @returns {AchievementGateway}
-     */
-    getAchievementGateway() {
-        throw new Error('Not implemented');
+    bestElement = array[0];
+
+    bestScore = scoreFunction(bestElement, 0);
+
+    for (let i = 1; i < size; i++) {
+        const el = array[i];
+
+        // compute score
+        const score = scoreFunction(el, i);
+
+        if (score > bestScore) {
+            bestScore = score;
+            bestElement = el;
+        }
+    }
+
+    return bestElement;
+}
+
+/**
+ * Base class for implementing achievement system API connectors
+ */
+class AchievementGateway {
+    constructor() {
+
     }
 
     /**
-     * @param {string[]} options
-     * @returns {string}
+     * Retrieve list of unlocked achievements
+     * @returns {Promise<String[]>} IDs of unlocked achievements
      */
-    pickDefaultLocale(options) {
+    getUnlocked() {
+        //needs to be overridden in subclass
         throw new Error('Not implemented');
     }
 
     /**
+     * Unlock an achievements by ID
+     * @param {String} id
      * @returns {Promise}
      */
-    startup() {
-        return Promise.resolve();
+    unlock(id) {
+        //needs to be overridden in subclass
+        throw new Error('Not implemented');
     }
-
+}
+
+class StorageAchievementGateway extends AchievementGateway {
     /**
-     * @returns {Promise}
+     *
+     * @param {Storage} storage
+     * @param {String} [key]
      */
-    shutdown() {
-        return Promise.resolve();
+    constructor(storage, key = "achievements") {
+        super();
+
+        this.storage = storage;
+
+        this.key = key;
+
+        this.last = Promise.resolve();
+    }
+
+    getUnlocked() {
+        return new Promise((resolve, reject) => {
+            this.storage.load(this.key, (list) => {
+
+                if (list === undefined) {
+                    resolve([]);
+                } else {
+                    resolve(list);
+                }
+
+            }, reject, noop);
+        });
     }
 
+    unlock(id) {
+        const storage = this.storage;
+
+        const promise = this.last.finally(() => {
+                return new Promise((resolve, reject) => {
+                    //read list of unlocked achievements
+                    storage.load(this.key, list => {
+
+                        let unlocked;
+                        if (list !== undefined) {
+                            if (list.includes(id)) {
+                                //achievement is already unlocked
+                                resolve();
+                                return;
+                            }
+
+                            unlocked = list.slice();
+
+                        } else {
+                            unlocked = [];
+                        }
+
+                        //modify unlocked achievements
+                        unlocked.push(id);
+
+                        //write back
+                        storage.store(this.key, unlocked, resolve, reject, noop);
+                    }, reject, noop);
+                });
+            }
+        );
+
+        this.last = promise;
+
+        return promise;
+    }
 }
 
 class Storage {
@@ -115760,138 +115894,43 @@ class IndexedDBStorage extends Storage {
     }
 }
 
-/**
- * Base class for implementing achievement system API connectors
- */
-class AchievementGateway {
-    constructor() {
-
-    }
-
+class EnginePlatform {
     /**
-     * Retrieve list of unlocked achievements
-     * @returns {Promise<String[]>} IDs of unlocked achievements
+     * @returns {Storage}
      */
-    getUnlocked() {
-        //needs to be overridden in subclass
+    getStorage() {
         throw new Error('Not implemented');
     }
 
     /**
-     * Unlock an achievements by ID
-     * @param {String} id
-     * @returns {Promise}
+     * @returns {AchievementGateway}
      */
-    unlock(id) {
-        //needs to be overridden in subclass
+    getAchievementGateway() {
         throw new Error('Not implemented');
     }
-}
-
-class StorageAchievementGateway extends AchievementGateway {
+
     /**
-     *
-     * @param {Storage} storage
-     * @param {String} [key]
+     * @param {string[]} options
+     * @returns {string}
      */
-    constructor(storage, key = "achievements") {
-        super();
-
-        this.storage = storage;
-
-        this.key = key;
-
-        this.last = Promise.resolve();
-    }
-
-    getUnlocked() {
-        return new Promise((resolve, reject) => {
-            this.storage.load(this.key, (list) => {
-
-                if (list === undefined) {
-                    resolve([]);
-                } else {
-                    resolve(list);
-                }
-
-            }, reject, noop);
-        });
-    }
-
-    unlock(id) {
-        const storage = this.storage;
-
-        const promise = this.last.finally(() => {
-                return new Promise((resolve, reject) => {
-                    //read list of unlocked achievements
-                    storage.load(this.key, list => {
-
-                        let unlocked;
-                        if (list !== undefined) {
-                            if (list.includes(id)) {
-                                //achievement is already unlocked
-                                resolve();
-                                return;
-                            }
-
-                            unlocked = list.slice();
-
-                        } else {
-                            unlocked = [];
-                        }
-
-                        //modify unlocked achievements
-                        unlocked.push(id);
-
-                        //write back
-                        storage.store(this.key, unlocked, resolve, reject, noop);
-                    }, reject, noop);
-                });
-            }
-        );
-
-        this.last = promise;
-
-        return promise;
+    pickDefaultLocale(options) {
+        throw new Error('Not implemented');
     }
-}
-
-/**
- * Picks element with highest score from the array using supplied scoring function.
- * If multiple elements with the same highest score exist, the result will be first such encountered element
- * @template T
- * @param {T[]} array
- * @param {function(el:T, index:number):number} scoreFunction
- * @returns {T|undefined}
- */
-function arrayPickBestElement(array, scoreFunction) {
-
-    let bestElement;
-    let bestScore;
 
-    const size = array.length;
-
-    if (size === 0) {
-        return undefined;
+    /**
+     * @returns {Promise}
+     */
+    startup() {
+        return Promise.resolve();
     }
 
-    bestElement = array[0];
-
-    bestScore = scoreFunction(bestElement, 0);
-
-    for (let i = 1; i < size; i++) {
-        const el = array[i];
-
-        // compute score
-        const score = scoreFunction(el, i);
-
-        if (score > bestScore) {
-            bestScore = score;
-            bestElement = el;
-        }
+    /**
+     * @returns {Promise}
+     */
+    shutdown() {
+        return Promise.resolve();
     }
 
-    return bestElement;
 }
 
 class WebEnginePlatform extends EnginePlatform {
@@ -115966,7 +116005,7 @@ class WebEnginePlatform extends EnginePlatform {
                 };
             });
 
-            const best = arrayPickBestElement(scoredKeys, o => o.score);
+            const best = array_pick_best_element(scoredKeys, o => o.score);
 
             if (best.score === 0) {
                 return 'en-gb';