@woosh/meep-engine 2.84.10 → 2.85.0

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);
 }
 
 /**
@@ -60814,7 +60805,7 @@ class Cache {
 
         if (
             this.weight > this.maxWeight
-            && new_weight >= this.maxWeight //make it less likely to drop entire cache
+            && new_weight <= this.maxWeight //make it less likely to drop entire cache
         ) {
             this.evictUntilWeight(this.maxWeight);
         }
@@ -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

package/package.json

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

package/src/core/cache/Cache.js

@@ -216,7 +216,7 @@ export class Cache {
 
         if (
             this.weight > this.maxWeight
-            && new_weight >= this.maxWeight //make it less likely to drop entire cache
+            && new_weight <= this.maxWeight //make it less likely to drop entire cache
         ) {
             this.evictUntilWeight(this.maxWeight);
         }

package/src/core/cache/LoadingCache.js

@@ -41,7 +41,7 @@ function record_get_value_weight(record) {
 /**
  * Asynchronous cache capable of resolving its own values by keys
  * Modelled on Guava's LoadingCache concept
- * @template K,V
+ * @template K, V
  */
 export class LoadingCache {
     /**
@@ -73,7 +73,6 @@ export class LoadingCache {
 
     /**
      * @see {@link Cache} for more details on what each parameter means
-     * @template K,V
      * @param [maxWeight]
      * @param [keyWeigher]
      * @param [valueWeigher]
@@ -183,6 +182,15 @@ export class LoadingCache {
         this.#internal.put(key, new Record(Promise.resolve(value), current_time_in_seconds()));
     }
 
+    /**
+     *
+     * @param {K} key
+     * @returns {boolean}
+     */
+    contains(key) {
+        return this.#internal.contains(key);
+    }
+
     /**
      *
      * @param {K} key

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

@@ -84,3 +84,36 @@ test("clear", async () => {
 
     expect(await cache.get("x")).toEqual(3);
 });
+
+test("eviction", async () => {
+
+    /**
+     *
+     * @type {LoadingCache<number, number>}
+     */
+    const cache = new LoadingCache({
+        valueWeigher(num) {
+            return num;
+        },
+        load: async () => {
+            return 2;
+        },
+        maxWeight: 6,
+    });
+
+    await cache.get(1);
+    await cache.get(2);
+    await cache.get(3);
+
+    expect(cache.contains(1)).toBe(true);
+    expect(cache.contains(2)).toBe(true);
+    expect(cache.contains(3)).toBe(true);
+
+    await cache.get(4);
+
+    expect(cache.contains(1)).toBe(false);
+    expect(cache.contains(2)).toBe(true);
+    expect(cache.contains(3)).toBe(true);
+    expect(cache.contains(4)).toBe(true);
+
+});

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/graphics/particles/node-based/editor/ParticleSpecificationEditorView.js

@@ -1,17 +1,17 @@
-import View from "../../../../../view/View.js";
 import { NodeGraphEditorView } from "../../../../../../editor/view/node-graph/NodeGraphEditorView.js";
 import { NodeGraphCamera } from "../../../../../../editor/view/node-graph/NodeGraphView.js";
-import ListView from "../../../../../view/common/ListView.js";
+import { downloadAsFile } from "../../../../../core/binary/downloadAsFile.js";
 import List from "../../../../../core/collection/list/List.js";
-import LabelView from "../../../../../view/common/LabelView.js";
-import { MouseEvents } from "../../../../input/devices/events/MouseEvents.js";
-import InterfaceCommand from "../../../../../view/interaction/InterfaceCommand.js";
-import { InteractionCommand } from "../../../../../view/interaction/InteractionCommand.js";
-import { serializeNodeGraphToJSON } from "../../../../../core/model/node-graph/json/serializeNodeGraphToJSON.js";
 import {
     deserializeNodeGraphFromJSON
 } from "../../../../../core/model/node-graph/json/deserializeNodeGraphFromJSON.js";
-import {downloadAsFile} from "../../../../../core/binary/downloadAsFile.js";
+import { serializeNodeGraphToJSON } from "../../../../../core/model/node-graph/json/serializeNodeGraphToJSON.js";
+import LabelView from "../../../../../view/common/LabelView.js";
+import ListView from "../../../../../view/common/ListView.js";
+import { InteractionCommand } from "../../../../../view/interaction/InteractionCommand.js";
+import InterfaceCommand from "../../../../../view/interaction/InterfaceCommand.js";
+import View from "../../../../../view/View.js";
+import { MouseEvents } from "../../../../input/devices/events/MouseEvents.js";
 
 export class ParticleSpecificationEditorView extends View {
     constructor() {
@@ -101,13 +101,13 @@ export class ParticleSpecificationEditorView extends View {
             function processFile(file) {
                 const fr = new FileReader();
 
-                fr.onload = () => {
+                fr.onload = async () => {
 
                     visual.nodes.clear();
 
                     const json = JSON.parse(fr.result);
 
-                    deserializeNodeGraphFromJSON({ graph: nodeGraph, json: json, node_registry: nodeRegistry });
+                    await deserializeNodeGraphFromJSON({ graph: nodeGraph, json: json, node_registry: nodeRegistry });
 
                     visual.layout(nodeGraph);
                 };