@woosh/meep-engine 2.115.0 → 2.116.1

package/build/meep.module.js

@@ -50988,9 +50988,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;
     }
@@ -50999,11 +51001,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);
 
         /*
@@ -59530,6 +59535,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 = `
@@ -59589,16 +59614,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
@@ -59607,13 +59622,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;
@@ -61407,7 +61422,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++) {
@@ -61423,14 +61438,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();
@@ -61442,7 +61457,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
@@ -61501,8 +61516,7 @@ class List {
     data = []
 
     /**
-     * @param {[]} [array]
-     * @constructor
+     * @param {T[]} [array]
      */
     constructor(array) {
 
@@ -61667,7 +61681,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;
@@ -61744,12 +61758,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]);
         }
     }
 
@@ -61859,7 +61871,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);
@@ -62186,7 +62198,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;
@@ -94307,7 +94319,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;
@@ -94525,7 +94537,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
@@ -105503,7 +105515,7 @@ class InputBinding {
 class InputController {
     /**
      *
-     * @param {Array} bindings
+     * @param {Array} [bindings]
      * @constructor
      */
     constructor(bindings = []) {
@@ -105519,6 +105531,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
@@ -114992,19 +115019,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
+                );
             });
         }
 
@@ -115036,7 +115063,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);
 
@@ -115487,43 +115514,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 {
@@ -115797,138 +115919,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 {
@@ -116003,7 +116030,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';

package/editor/view/ecs/HierarchicalEntityListView.js

@@ -1,4 +1,4 @@
-import { arraySetSortingDiff } from "../../../src/core/collection/array/arraySetSortingDiff.js";
+import { array_set_diff_sorting } from "../../../src/core/collection/array/array_set_diff_sorting.js";
 import List from "../../../src/core/collection/list/List.js";
 import Signal from "../../../src/core/events/signal/Signal.js";
 import { number_compare_ascending } from "../../../src/core/primitives/numbers/number_compare_ascending.js";
@@ -50,7 +50,7 @@ export class HierarchicalEntityListView extends EmptyView {
         });
 
         // perform patch
-        const diff = arraySetSortingDiff(new_roots, this.#roots.asArray(), number_compare_ascending);
+        const diff = array_set_diff_sorting(new_roots, this.#roots.asArray(), number_compare_ascending);
 
         for (let i = 0; i < diff.uniqueB.length; i++) {
             const removal_id = diff.uniqueB[i];

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.115.0",
+  "version": "2.116.1",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/array/{compareArrays.d.ts → array_compare.d.ts}

@@ -5,5 +5,5 @@
  * @param {function(T,T):number} comparator
  * @return {number}
  */
-export function compareArrays<T>(as: T[], bs: T[], comparator: (arg0: T, arg1: T) => number): number;
-//# sourceMappingURL=compareArrays.d.ts.map
+export function array_compare<T>(as: T[], bs: T[], comparator: (arg0: T, arg1: T) => number): number;
+//# sourceMappingURL=array_compare.d.ts.map

package/src/core/collection/array/array_compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_compare.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_compare.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,qFAHyB,MAAM,GACnB,MAAM,CA0BjB"}

package/src/core/collection/array/{compareArrays.js → array_compare.js}

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  * @template T
  * @param {T[]} as
@@ -5,7 +7,9 @@
  * @param {function(T,T):number} comparator
  * @return {number}
  */
-export function compareArrays(as, bs, comparator) {
+export function array_compare(as, bs, comparator) {
+    assert.isFunction(comparator,'comparator');
+
     const n = as.length;
     const m = bs.length;
 

package/src/core/collection/array/{arrayIndexByEquality.d.ts → array_index_by_equality.d.ts}

@@ -6,5 +6,5 @@
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-export function arrayIndexByEquality<T>(array: T[], element: T, equals: any): number;
-//# sourceMappingURL=arrayIndexByEquality.d.ts.map
+export function array_index_by_equality<T>(array: T[], element: T, equals: any): number;
+//# sourceMappingURL=array_index_by_equality.d.ts.map

package/src/core/collection/array/array_index_by_equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_index_by_equality.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_index_by_equality.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,iFAFa,MAAM,CAclB"}

package/src/core/collection/array/{arrayIndexByEquality.js → array_index_by_equality.js}

@@ -6,7 +6,7 @@
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-export function arrayIndexByEquality(array, element, equals) {
+export function array_index_by_equality(array, element, equals) {
     const n = array.length;
 
     for (let i = 0; i < n; i++) {

package/src/core/collection/array/array_pick_best_element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_pick_best_element.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_element.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8EAkCC"}

package/src/core/collection/array/{arrayPickBestElement.js → array_pick_best_element.js}

@@ -8,9 +8,9 @@ import { assert } from "../../assert.js";
  * @param {function(el:T, index:number):number} scoreFunction
  * @returns {T|undefined}
  */
-export function arrayPickBestElement(array, scoreFunction) {
+export function array_pick_best_element(array, scoreFunction) {
     assert.notEqual(array, undefined, 'array is undefined');
-    assert.typeOf(scoreFunction, 'function', 'scoreFunction');
+    assert.isFunction(scoreFunction, 'scoreFunction');
 
     let bestElement;
     let bestScore;

package/src/core/collection/array/array_pick_best_elements.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {function(el:T, index:number):number} scoreFunction
+ * @returns {T[]}
+ */
+export function array_pick_best_elements<T>(array: T[], scoreFunction: any): T[];
+//# sourceMappingURL=array_pick_best_elements.d.ts.map