@woosh/meep-engine 2.84.11 → 2.85.1

package/build/meep.module.js

@@ -49071,15 +49071,21 @@ function interpolate_bicubic(t, a, b, c, d) {
 function computeStridedIntegerArrayHash(
     array, offset, length, stride
 ) {
-    let result = length;
+    let hash = length;
 
     for (let i = offset; i < length; i += stride) {
-        const value = array[i];
+        const value = array[i] >>> 0; //force int32
 
-        result = ((result * 31) + value) | 0;
+        /**
+         * 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;
     }
 
-    return result;
+    // force uint32
+    return hash >>> 0;
 }
 
 function typedArrayConstructorByInstance(a) {
@@ -50478,22 +50484,7 @@ Vector1.one = Object.freeze(new Vector1(1));
  * @param {number} length
  */
 function computeIntegerArrayHash(data, offset, length) {
-    const end = offset + length;
-
-    let hash = length;
-
-    for (let i = offset; i < end; i++) {
-        const singleValue = data[i];
-        /**
-         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
-         * (h<<5) - h ===  h*31
-         * @type {number}
-         */
-        hash = ((hash << 5) - hash) + singleValue;
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
+   return computeStridedIntegerArrayHash(data, offset, length, 1);
 }
 
 /**
@@ -61166,6 +61157,7 @@ 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
  * @template T
  * @param {T[]} a
  * @param {T[]} b
@@ -91082,7 +91074,21 @@ class StaticKnowledgeDatabase {
      * @private
      */
     __specs = [];
-    
+
+    /**
+     *
+     * @type {boolean}
+     */
+    #validation_enabled = false;
+
+    /**
+     *
+     * @param {boolean} v
+     */
+    set validation_enabled(v) {
+        this.#validation_enabled = v;
+    }
+
 
     /**
      * Reset database, drop all table data
@@ -91325,7 +91331,7 @@ class StaticKnowledgeDatabase {
         return Promise.all(promises).then(() => {
             let p = this.link(am, executor);
 
-            if (!ENV_PRODUCTION) {
+            if (this.#validation_enabled) {
                 p = p.then(() => this.validate(executor));
             }
 
@@ -103172,14 +103178,16 @@ class Engine {
      *
      * @param {EnginePlatform} platform
      * @param {EntityManager} [entityManager]
-     * @param enableGraphics
-     * @param enableAudio
+     * @param {boolean} [enableGraphics]
+     * @param {boolean} [enableAudio]
+     * @param {boolean} [validation]
      * @constructor
      */
     constructor(platform, {
         entityManager,
         enableGraphics = true,
-        enableAudio = true
+        enableAudio = true,
+        validation = true
     } = {}) {
 
         /**
@@ -103193,6 +103201,7 @@ class Engine {
          * @type {StaticKnowledgeDatabase}
          */
         this.staticKnowledge = new StaticKnowledgeDatabase();
+        this.staticKnowledge.validation_enabled = validation;
 
         /**
          *
@@ -103586,7 +103595,7 @@ class Engine {
             requestAnimationFrame(this.#animation_frame);
 
             //start simulation
-            this.ticker.start({maxTimeout: 200});
+            this.ticker.start({ maxTimeout: 200 });
             //self.uiController.init(self);
 
             //load options

package/package.json

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

package/src/core/cache/LoadingCache.js

@@ -148,16 +148,17 @@ export class LoadingCache {
 
         this.#internal.put(key, record);
 
-        promise.then((value) => {
-            // re-score value based on actual data
-            record.weight = this.#value_weigher(value);
-            this.#internal.updateElementWeight(key);
-        });
-
-        promise.catch(() => {
-            // mark as failure
-            record.failed = true;
-        });
+        promise.then(
+            (value) => {
+                // re-score value based on actual data
+                record.weight = this.#value_weigher(value);
+                this.#internal.updateElementWeight(key);
+            },
+            () => {
+                // mark as failure
+                record.failed = true;
+            }
+        );
 
         return record;
     }

package/src/core/cache/LoadingCache.spec.js

@@ -1,26 +1,27 @@
-import { delay } from "../process/delay.js";
 import { LoadingCache } from "./LoadingCache.js";
 
-test("successful load", async () => {
+jest.useFakeTimers();
+
+test("successful load", () => {
     const cache = new LoadingCache({
         async load(key) {
             return 17;
         }
     });
 
-    expect(await cache.get(1)).toEqual(17);
+    expect( cache.get(1)).resolves.toEqual(17);
 });
 
-test("when loader throws an exception, we should get a failed promise", async () => {
+test("when loader throws an exception, we should get a failed promise",  () => {
     const cache = new LoadingCache({
         load(key) {
-            throw 1;
+            throw "Designed Thrown Thing";
         }
     });
 
     const promise = cache.get("a");
 
-    await expect(promise).rejects.toEqual(1);
+    expect(promise).rejects.toEqual("Designed Thrown Thing");
 });
 
 test("record reuse", async () => {
@@ -30,8 +31,8 @@ test("record reuse", async () => {
         load
     });
 
-    expect(await cache.get(1)).toEqual(17);
-    expect(await cache.get(1)).toEqual(17);
+    await expect(cache.get(1)).resolves.toEqual(17);
+    await expect(cache.get(1)).resolves.toEqual(17);
 
     expect(load).toHaveBeenCalledTimes(1);
 });
@@ -44,47 +45,23 @@ test("timeout reload reuse", async () => {
 
     const cache = new LoadingCache({
         load,
-        timeToLive: 0.0000001
+        timeToLive: 0.00000001
     });
 
     const request_1 = await cache.get(1);
     expect(request_1).toEqual(11);
 
-    await delay(2);
+    jest.advanceTimersByTime(1);
 
     const request_2 = await cache.get(1);
     expect(request_2).toEqual(5);
 
-    await delay(2);
+    jest.advanceTimersByTime(1);
 
     const request_3 = await cache.get(1);
     expect(request_3).toEqual(3);
 });
 
-test("insert element directly", async () => {
-
-    const cache = new LoadingCache({
-        load: async () => 3
-    });
-
-    cache.put("x", 1);
-
-    expect(await cache.get("x")).toEqual(1);
-});
-
-test("clear", async () => {
-
-    const cache = new LoadingCache({
-        load: async () => 3
-    });
-
-    cache.put("x", 1);
-
-    cache.clear();
-
-    expect(await cache.get("x")).toEqual(3);
-});
-
 test("eviction", async () => {
 
     /**
@@ -111,11 +88,33 @@ test("eviction", async () => {
 
     await cache.get(4);
 
-    await delay(1);
-
     expect(cache.contains(1)).toBe(false);
     expect(cache.contains(2)).toBe(true);
     expect(cache.contains(3)).toBe(true);
     expect(cache.contains(4)).toBe(true);
 
-});
+});
+
+test("insert element directly", async () => {
+
+    const cache = new LoadingCache({
+        load: async () => 3
+    });
+
+    cache.put("x", 1);
+
+    expect(await cache.get("x")).toEqual(1);
+});
+
+test("clear", async () => {
+
+    const cache = new LoadingCache({
+        load: async () => 3
+    });
+
+    cache.put("x", 1);
+
+    cache.clear();
+
+    expect(await cache.get("x")).toEqual(3);
+});

package/src/core/collection/array/arraySetDiff.js

@@ -5,6 +5,7 @@ import { arrayIndexByEquality } from "./arrayIndexByEquality.js";
 
 /**
  * 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
  * @template T
  * @param {T[]} a
  * @param {T[]} b

package/src/core/model/node-graph/json/deserializeNodeGraphFromJSON.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../assert.js";
-import { NodeInstance } from "../node/NodeInstance.js";
 import { abstractJSONDeserializer } from "../../../json/abstractJSONDeserializer.js";
+import { NodeInstance } from "../node/NodeInstance.js";
 import { NodeRegistry } from "../node/NodeRegistry.js";
 
 /**
@@ -25,47 +25,73 @@ function nodeParametersFromJSON(node, json, deserializers) {
 
 /**
  *
- * @param {NodeGraph} graph
- * @param {{nodes:[], connections:[], descriptions:[]}} json
- * @param {NodeRegistry} [node_registry]
- * @param {Map<string, function>} [deserializers]
- * @param {boolean} [allow_node_id_collisions]
+ * @param {[]} j_descriptions
+ * @param {Map<string,function>} deserializers
+ * @param {NodeRegistry} node_registry
+ * @param {boolean} allow_node_id_collisions
+ * @returns {Promise<NodeDescription[]>}
  */
-export function deserializeNodeGraphFromJSON({
-                                                 graph,
-                                                 json,
-                                                 node_registry = new NodeRegistry(),
-                                                 deserializers = new Map(),
-                                                 allow_node_id_collisions = false
-                                             }) {
-
-    const j_nodes = json.nodes;
-    const j_connections = json.connections;
-    const j_descriptions = json.descriptions;
-
-
-    assert.defined(j_nodes, 'json.nodes');
-    assert.defined(j_connections, 'json.connections');
-    assert.defined(j_descriptions, 'json.descriptions');
+async function deserializeNodeDescriptors(j_descriptions, deserializers, node_registry, allow_node_id_collisions) {
+    /**
+     *
+     * @type {NodeDescription[]}
+     */
+    const result = [];
 
-    graph.reset();
+    /**
+     *
+     * @type {{index:number, promise:Promise<NodeDescription>}[]}
+     */
+    const deferred = [];
 
     /**
      *
      * @type {NodeDescription[]}
      */
-    const descriptions = [];
+    const deserialized = [];
 
-    // parse node descriptions
-    for (let i = 0; i < j_descriptions.length; i++) {
+
+    const node_description_count = j_descriptions.length;
+
+    // parse node result
+    for (let i = 0; i < node_description_count; i++) {
         const jDescription = j_descriptions[i];
 
-        const loaded_node = abstractJSONDeserializer(jDescription, deserializers);
+        const result = abstractJSONDeserializer(jDescription, deserializers);
+
+        if (result instanceof Promise) {
+            deferred.push({
+                index: i,
+                promise: result
+            });
+        } else {
+            deserialized[i] = result;
+        }
+
+    }
+
+    if (deferred.length > 0) {
+        const resolved = await Promise.all(deferred.map(m => m.promise));
+
+        for (let i = 0; i < deferred.length; i++) {
+            const node_description = resolved[i];
+
+            const spec = deferred[i];
+
+            deserialized[spec.index] = node_description;
+        }
+    }
+
+    for (let i = 0; i < node_description_count; i++) {
+
+        const loaded_node = deserialized[i];
 
         if (
             typeof loaded_node !== "object"
             || loaded_node.isNodeDescription !== true
         ) {
+            const jDescription = j_descriptions[i];
+
             throw new Error(`Deserialized object was expected to be a NodeDescription, instead got something else. Source JSON[${i}]: ${jDescription}`);
         }
 
@@ -73,7 +99,7 @@ export function deserializeNodeGraphFromJSON({
 
         if (existing_node === undefined) {
 
-            descriptions[i] = loaded_node;
+            result[i] = loaded_node;
 
             // make sure to register the node
             node_registry.addNode(loaded_node);
@@ -85,7 +111,7 @@ export function deserializeNodeGraphFromJSON({
                 // collision exists
 
                 if (allow_node_id_collisions) {
-                    descriptions[i] = loaded_node;
+                    result[i] = loaded_node;
                 } else {
                     // illegal collision
                     throw new Error(`Loaded node does not match the one in the registry. Loaded: ${loaded_node}, Existing: ${existing_node}`);
@@ -94,11 +120,45 @@ export function deserializeNodeGraphFromJSON({
             } else {
 
                 // re-use node from registry
-                descriptions[i] = existing_node;
+                result[i] = existing_node;
             }
         }
-
     }
+    return result;
+}
+
+/**
+ *
+ * @param {NodeGraph} graph
+ * @param {{nodes:[], connections:[], descriptions:[]}} json
+ * @param {NodeRegistry} [node_registry]
+ * @param {Map<string, function>} [deserializers]
+ * @param {boolean} [allow_node_id_collisions]
+ */
+export async function deserializeNodeGraphFromJSON({
+                                                       graph,
+                                                       json,
+                                                       node_registry = new NodeRegistry(),
+                                                       deserializers = new Map(),
+                                                       allow_node_id_collisions = false
+                                                   }) {
+
+    const j_nodes = json.nodes;
+    const j_connections = json.connections;
+    const j_descriptions = json.descriptions;
+
+    assert.defined(j_nodes, 'json.nodes');
+    assert.defined(j_connections, 'json.connections');
+    assert.defined(j_descriptions, 'json.descriptions');
+
+    graph.reset();
+
+    const descriptions = await deserializeNodeDescriptors(
+        j_descriptions,
+        deserializers,
+        node_registry,
+        allow_node_id_collisions
+    );
 
     // parse nodes
     const node_count = j_nodes.length;

package/src/core/primitives/array/computeIntegerArrayHash.js

@@ -1,3 +1,5 @@
+import { computeStridedIntegerArrayHash } from "./computeStridedIntegerArrayHash.js";
+
 /**
  *
  * @param {Uint8Array|number[]|ArrayLike<number>|IArguments} data
@@ -5,20 +7,5 @@
  * @param {number} length
  */
 export function computeIntegerArrayHash(data, offset, length) {
-    const end = offset + length;
-
-    let hash = length;
-
-    for (let i = offset; i < end; i++) {
-        const singleValue = data[i];
-        /**
-         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
-         * (h<<5) - h ===  h*31
-         * @type {number}
-         */
-        hash = ((hash << 5) - hash) + singleValue;
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
+   return computeStridedIntegerArrayHash(data, offset, length, 1);
 }

package/src/core/primitives/array/computeStridedIntegerArrayHash.js

@@ -9,13 +9,19 @@
 export function computeStridedIntegerArrayHash(
     array, offset, length, stride
 ) {
-    let result = length;
+    let hash = length;
 
     for (let i = offset; i < length; i += stride) {
-        const value = array[i];
+        const value = array[i] >>> 0; //force int32
 
-        result = ((result * 31) + value) | 0;
+        /**
+         * 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;
     }
 
-    return result;
+    // force uint32
+    return hash >>> 0;
 }

package/src/engine/Engine.d.ts

@@ -1,20 +1,21 @@
-import {EnginePlatform} from "./platform/EnginePlatform";
-import SceneManager from "./scene/SceneManager";
+import ConcurrentExecutor from "../core/process/executor/ConcurrentExecutor";
+import View from "../view/View";
+import {AssetManager} from "./asset/AssetManager";
+import {EntityManager} from "./ecs/EntityManager";
 import {GraphicsEngine} from "./graphics/GraphicsEngine";
-import SoundEngine from "./sound/SoundEngine";
 import KeyboardDevice from "./input/devices/KeyboardDevice";
 import {PointerDevice} from "./input/devices/PointerDevice";
-import {AssetManager} from "./asset/AssetManager";
-import {EntityManager} from "./ecs/EntityManager";
-import View from "../view/View";
-import Ticker from "./simulation/Ticker";
+import {EnginePlatform} from "./platform/EnginePlatform";
 import {EnginePluginManager} from "./plugin/EnginePluginManager";
-import ConcurrentExecutor from "../core/process/executor/ConcurrentExecutor";
+import SceneManager from "./scene/SceneManager";
+import Ticker from "./simulation/Ticker";
+import SoundEngine from "./sound/SoundEngine";
 
 export interface IEngineInitializationOptions {
     entityManager?: EntityManager,
     enableAudio?: boolean
     enableGraphics?: boolean
+    validation?:boolean
 }
 
 export default class Engine {

package/src/engine/Engine.js

@@ -2,30 +2,30 @@
  *
  */
 
-import {PerspectiveCamera as ThreePerspectiveCamera} from 'three';
-import {assert} from "../core/assert.js";
+import { PerspectiveCamera as ThreePerspectiveCamera } from 'three';
+import { assert } from "../core/assert.js";
 import Vector1 from "../core/geom/Vector1.js";
-import {Localization} from "../core/localization/Localization.js";
-import {ModuleRegistry} from "../core/model/ModuleRegistry.js";
+import { Localization } from "../core/localization/Localization.js";
+import { ModuleRegistry } from "../core/model/ModuleRegistry.js";
 import ObservedBoolean from "../core/model/ObservedBoolean.js";
 import ConcurrentExecutor from '../core/process/executor/ConcurrentExecutor.js';
 import EmptyView from "../view/elements/EmptyView.js";
-import {ViewStack} from "../view/elements/navigation/ViewStack.js";
+import { ViewStack } from "../view/elements/navigation/ViewStack.js";
 
-import {AssetManager} from './asset/AssetManager.js';
+import { AssetManager } from './asset/AssetManager.js';
 import Preloader from "./asset/preloader/Preloader.js";
-import {MetricCollection} from "./development/performance/MetricCollection.js";
-import {MetricStatistics} from "./development/performance/MetricStatistics.js";
-import {PeriodicConsolePrinter} from "./development/performance/monitor/PeriodicConsolePrinter.js";
-import {EntityManager} from "./ecs/EntityManager.js";
-import {BinarySerializationRegistry} from "./ecs/storage/binary/BinarySerializationRegistry.js";
-import {GraphicsEngine} from './graphics/GraphicsEngine.js';
+import { MetricCollection } from "./development/performance/MetricCollection.js";
+import { MetricStatistics } from "./development/performance/MetricStatistics.js";
+import { PeriodicConsolePrinter } from "./development/performance/monitor/PeriodicConsolePrinter.js";
+import { EntityManager } from "./ecs/EntityManager.js";
+import { BinarySerializationRegistry } from "./ecs/storage/binary/BinarySerializationRegistry.js";
+import { GraphicsEngine } from './graphics/GraphicsEngine.js';
 import KeyboardDevice from "./input/devices/KeyboardDevice.js";
-import {PointerDevice} from "./input/devices/PointerDevice.js";
-import {StaticKnowledgeDatabase} from "./knowledge/database/StaticKnowledgeDatabase.js";
-import {logger} from "./logging/GlobalLogger.js";
-import {OptionGroup} from "./options/OptionGroup.js";
-import {EnginePluginManager} from "./plugin/EnginePluginManager.js";
+import { PointerDevice } from "./input/devices/PointerDevice.js";
+import { StaticKnowledgeDatabase } from "./knowledge/database/StaticKnowledgeDatabase.js";
+import { logger } from "./logging/GlobalLogger.js";
+import { OptionGroup } from "./options/OptionGroup.js";
+import { EnginePluginManager } from "./plugin/EnginePluginManager.js";
 import SceneManager from "./scene/SceneManager.js";
 import Ticker from "./simulation/Ticker.js";
 import SoundEngine from './sound/SoundEngine.js';
@@ -52,14 +52,16 @@ class Engine {
      *
      * @param {EnginePlatform} platform
      * @param {EntityManager} [entityManager]
-     * @param enableGraphics
-     * @param enableAudio
+     * @param {boolean} [enableGraphics]
+     * @param {boolean} [enableAudio]
+     * @param {boolean} [validation]
      * @constructor
      */
     constructor(platform, {
         entityManager,
         enableGraphics = true,
-        enableAudio = true
+        enableAudio = true,
+        validation = true
     } = {}) {
         assert.defined(platform, 'platform');
 
@@ -74,6 +76,7 @@ class Engine {
          * @type {StaticKnowledgeDatabase}
          */
         this.staticKnowledge = new StaticKnowledgeDatabase();
+        this.staticKnowledge.validation_enabled = validation;
 
         /**
          *
@@ -468,7 +471,7 @@ class Engine {
             requestAnimationFrame(this.#animation_frame);
 
             //start simulation
-            this.ticker.start({maxTimeout: 200});
+            this.ticker.start({ maxTimeout: 200 });
             //self.uiController.init(self);
 
             //load options