@woosh/meep-engine 2.115.0 → 2.116.1

package/build/meep.cjs

@@ -50990,9 +50990,11 @@ class Vector4 {
 /**
  *
  * @param {string|null|undefined} string
+ * @param {number} [start]
+ * @param {number} [length] how many characters to hash, defaults to full string length
  * @returns {number}
  */
-function computeStringHash(string) {
+function computeStringHash(string, start, length) {
     if (string === null) {
         return 0;
     }
@@ -51001,11 +51003,14 @@ function computeStringHash(string) {
         return 1;
     }
 
-    const length = string.length;
+    let _start = start ?? 0;
+    let _length = length ?? string.length - _start;
 
-    let hash = length;
+    let hash = _length;
 
-    for (let i = 0; i < length; i++) {
+    const end = _start + _length;
+
+    for (let i = _start; i < end; i++) {
         const code_point = string.charCodeAt(i);
 
         /*
@@ -59532,6 +59537,26 @@ const AmbientOcclusionShader = function () {
     }
 };
 
+/**
+ *
+ * @param {number} sigma distance from mean
+ * @param {number} v Variance
+ * @returns {number}
+ */
+function gaussian$1(sigma, v) {
+    return Math.exp(-(v * v) / (2 * sigma * sigma));
+}
+
+/**
+ * Normal Probability Distribution Function
+ * @param {number} x
+ * @param {number} sigma
+ * @return {number}
+ */
+function pdf_normal(x, sigma) {
+    return 0.39894 * gaussian$1(sigma, x) / sigma;
+}
+
 const KERNEL_SIZE = 15;
 
 const fragment$1 = `
@@ -59591,16 +59616,6 @@ void main(void) {
 }
 `;
 
-/**
- * Normal Probability Distribution Function
- * @param {number} x
- * @param {number} sigma
- * @return {number}
- */
-function normpdf(x, sigma) {
-    return 0.39894 * Math.exp(-0.5 * x * x / (sigma * sigma)) / sigma;
-}
-
 /**
  *
  * @param {number} sigma
@@ -59609,13 +59624,13 @@ function normpdf(x, sigma) {
  */
 function DenoiseShader(sigma = 10, filterSmoothness = 0.2) {
     // compute zNorm
-    const zNorm = 1 / normpdf(0, filterSmoothness);
+    const zNorm = 1 / pdf_normal(0, filterSmoothness);
 
     // build kernel
     const kernel = new Float32Array(KERNEL_SIZE);
     const kSize = Math.floor((KERNEL_SIZE - 1) / 2);
     for (let i = 0; i <= kSize; i++) {
-        const v = normpdf(i, sigma);
+        const v = pdf_normal(i, sigma);
 
         kernel[kSize + i] = v;
         kernel[kSize - i] = v;
@@ -61409,7 +61424,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++) {
@@ -61425,14 +61440,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();
@@ -61444,7 +61459,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
@@ -61503,8 +61518,7 @@ class List {
     data = []
 
     /**
-     * @param {[]} [array]
-     * @constructor
+     * @param {T[]} [array]
      */
     constructor(array) {
 
@@ -61669,7 +61683,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;
@@ -61746,12 +61760,10 @@ class List {
      * @param {Array.<T>} elements
      */
     addAllUnique(elements) {
-        const data = this.data;
-
-        const length = data.length;
+        const length = elements.length;
 
         for (let i = 0; i < length; i++) {
-            this.addUnique(data[i]);
+            this.addUnique(elements[i]);
         }
     }
 
@@ -61861,7 +61873,7 @@ class List {
     /**
      *
      * @param {function(a:T, b:T):number} [compare_function]
-     * @returns {List}
+     * @returns {this}
      */
     sort(compare_function) {
         Array.prototype.sort.call(this.data, compare_function);
@@ -62188,7 +62200,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;
@@ -94309,7 +94321,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;
@@ -94527,7 +94539,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
@@ -105505,7 +105517,7 @@ class InputBinding {
 class InputController {
     /**
      *
-     * @param {Array} bindings
+     * @param {Array} [bindings]
      * @constructor
      */
     constructor(bindings = []) {
@@ -105521,6 +105533,21 @@ class InputController {
         };
     }
 
+    /**
+     *
+     * @param {string} path
+     * @param {function} action
+     * @returns {InputBinding}
+     */
+    bind(path, action) {
+
+        const binding = new InputBinding({ path, listener: action });
+
+        this.mapping.add(binding);
+
+        return binding;
+    }
+
     /**
      *
      * @param {Array} bindings
@@ -114994,19 +115021,19 @@ class KeyboardCameraController {
         function registerToggle(keys, object, propertyName) {
             keys.forEach((keyName) => {
 
-                inputController.mapping.add({
-                    path: "keyboard/keys/" + keyName + "/down",
-                    listener: () => {
+                inputController.bind(
+                    "keyboard/keys/" + keyName + "/down",
+                    () => {
                         object[propertyName] = true;
 
                         //send interaction event
                         ecd.sendEvent(cameraController.entity, 'user-input');
                     }
-                });
-                inputController.mapping.add({
-                    path: "keyboard/keys/" + keyName + "/up",
-                    listener: () => object[propertyName] = false
-                });
+                );
+                inputController.bind(
+                    "keyboard/keys/" + keyName + "/up",
+                    () => object[propertyName] = false
+                );
             });
         }
 
@@ -115038,7 +115065,7 @@ class KeyboardCameraController {
                 return;
             }
 
-            let displacement = cameraPanSpeed.clone().multiplyScalar(keyboardPanSpeed * timeDelta);
+            const displacement = cameraPanSpeed.clone().multiplyScalar(keyboardPanSpeed * timeDelta);
 
             const camera_transform = ecd.getComponent(cameraController.entity, Transform);
 
@@ -115489,43 +115516,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 {
@@ -115799,138 +115921,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 {
@@ -116005,7 +116032,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';