@woosh/meep-engine 2.47.32 → 2.47.34

package/build/meep.module.js

@@ -60433,11 +60433,13 @@ class MapEntry {
      * @param {number} hash
      */
     constructor(key, value, hash) {
+
         /**
          *
          * @type {K}
          */
         this.key = key;
+
         /**
          *
          * @type {V}
@@ -60449,6 +60451,7 @@ class MapEntry {
          * @type {number}
          */
         this.hash = hash;
+
     }
 }
 
@@ -60464,6 +60467,13 @@ const DEFAULT_INITIAL_CAPACITY = 16;
  */
 const DEFAULT_LOAD_FACTOR = 0.75;
 
+/**
+ * Multiply previous size by this number when growing the table
+ * @readonly
+ * @type {number}
+ */
+const GROWTH_FACTOR = 2;
+
 /**
  * Implements part of {@link Map} interface
  * @copyright Alex Goldring (c) 2023
@@ -60488,7 +60498,9 @@ class HashMap {
         assert.isFunction(keyHashFunction, 'keyHashFunction');
         assert.isFunction(keyEqualityFunction, 'keyEqualityFunction');
         assert.isNonNegativeInteger(capacity, 'capacity');
+
         assert.isNumber(loadFactor, 'loadFactor');
+        assert.greaterThan(loadFactor, 0, 'loadFactor must be > 0');
 
         /**
          *
@@ -60601,6 +60613,8 @@ class HashMap {
      * @private
      */
     __compute_bucket_index(hash) {
+        assert.isInteger(hash, 'hash');
+
         // mix the input hash to minimize potential impact of poor hash function spread
         const mixed_hash = (hash >>> 16) ^ hash;
 
@@ -60664,18 +60678,19 @@ class HashMap {
 
         }
 
-        bucket.push(new MapEntry(key, value,raw_hash));
+        bucket.push(new MapEntry(key, value, raw_hash));
 
         const old_size = this.size;
         const new_size = old_size + 1;
         this.size = new_size;
 
         // compute actual current load
-        const load = new_size / this.__bucket_count;
+        const bucket_count = this.__bucket_count;
+        const load = new_size / bucket_count;
 
         if (load > this.__load_factor) {
             // current load is too high, increase table size
-            this.setBucketCount(this.__bucket_count * 2);
+            this.setBucketCount(bucket_count * GROWTH_FACTOR);
         }
     }
 
@@ -60800,8 +60815,11 @@ class HashMap {
     /**
      *
      * @param {function(message:string, key:K, value:V)} callback
+     * @param {*} [thisArg]
+     * @returns {boolean}
      */
-    verifyHashes(callback) {
+    verifyHashes(callback, thisArg) {
+        let all_hashes_valid = true;
 
         let h, i;
 
@@ -60827,15 +60845,25 @@ class HashMap {
                 //check hash
                 const raw_hash = this.keyHashFunction(entry.key);
 
+                if (entry.hash !== raw_hash) {
+                    callback.call(thisArg, `Hash stored on the entry(=${entry.hash}) is different from the computed key hash(=${raw_hash}).`, entry.key, entry.value);
+
+                    all_hashes_valid = false;
+                }
+
                 const actual_bucket_index = this.__compute_bucket_index(raw_hash);
 
                 const stored_bucket_index = parseInt(h);
 
                 if (actual_bucket_index !== stored_bucket_index) {
-                    callback(`Hash of key has changed. old=${stored_bucket_index}, new=${actual_bucket_index}`, entry.key, entry.value);
+                    callback.call(thisArg, `Hash of key has changed. old=${stored_bucket_index}, new=${actual_bucket_index}`, entry.key, entry.value);
+
+                    all_hashes_valid = false;
                 }
             }
         }
+
+        return all_hashes_valid;
     }
 
     /**
@@ -61499,6 +61527,18 @@ class Cache {
 
         this.weight = 0;
     }
+
+    /**
+     *
+     * @param {function(message:string, key:Key, value:Value)} callback
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     */
+    validate(callback, thisArg) {
+        return this.data.verifyHashes((msg, key, entry) => {
+            callback.call(thisArg, msg, key, entry.value);
+        });
+    }
 }
 
 /**
@@ -77809,6 +77849,24 @@ class StaticMaterialCache {
         return material;
 
     }
+
+    /**
+     *
+     * @param {function(string)} error_consumer
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     */
+    validate(error_consumer, thisArg) {
+        const materials_valid = this.materialCache.validate((message, key, value) => {
+            error_consumer.call(thisArg, `Material error: ${message}. Material ${key}`);
+        });
+        const textures_valid = this.textureCache.validate((message, key, value) => {
+            error_consumer.call(thisArg, `Texture error: ${message}. Texture ${key}`);
+        });
+
+        return materials_valid
+            && textures_valid;
+    }
 }
 
 /**
@@ -78461,42 +78519,90 @@ class InstancedMeshGroup {
     }
 }
 
+class SGCacheKey {
+    geometry = -1;
+    material = -1;
+    /**
+     *
+     * @type {DrawMode}
+     */
+    mode = DrawMode.Triangles;
+
+    flags = 0;
+
+    hash(){
+        return this.geometry ^ this.material;
+    }
+
+    /**
+     *
+     * @param {SGCacheKey} other
+     * @returns {boolean}
+     */
+    equals(other){
+        return this.geometry === other.geometry
+        && this.material === other.material
+        && this.mode === other.mode
+        && this.flags === other.flags;
+    }
+
+    /**
+     *
+     * @param {SGCacheKey} other
+     */
+    copy(other){
+        this.geometry = other.geometry;
+        this.material = other.material;
+        this.mode = other.mode;
+        this.flags = other.flags;
+    }
+
+    clone(){
+        const r = new SGCacheKey();
+
+        r.copy(this);
+        
+        return r;
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     */
+    fromSG(sg){
+        this.geometry = sg.geometry.id;
+        this.material = sg.material.id;
+        this.mode = sg.mode;
+        this.flags = sg.flags;
+    }
+}
+
 const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
 
+/**
+ * @readonly
+ * @type {SGCacheKey}
+ */
+const scratch_key = new SGCacheKey();
+
 class InstancedRendererAdapter extends AbstractRenderAdapter {
-    constructor() {
-        super();
 
-        /**
-         *
-         * @type {HashMap<ShadedGeometry, InstancedMeshGroup>}
-         * @private
-         */
-        this.__instanced_meshes = new HashMap({
-            keyHashFunction(sg) {
-                return sg.geometry.id
-                    ^ sg.material.id
-                    ^ sg.mode
-                    ;
-            },
-            keyEqualityFunction(a, b) {
-                return a.material.id === b.material.id
-                    && a.geometry.id === b.geometry.id
-                    && a.mode === b.mode
-                    && (a.flags & INSTANCED_EQUALITY_FLAGS) === (b.flags & INSTANCED_EQUALITY_FLAGS)
-                    ;
-            }
-        });
+    /**
+     *
+     * @type {HashMap<SGCacheKey, InstancedMeshGroup>}
+     * @private
+     */
+    __instanced_meshes = new HashMap();
+
+    /**
+     *
+     * @type {Set<InstancedMeshGroup>}
+     * @private
+     */
+    __active_meshes = new Set();
 
-        /**
-         *
-         * @type {Set<InstancedMeshGroup>}
-         * @private
-         */
-        this.__active_meshes = new Set();
-    }
 
     score(geometry, material, instance_count) {
         if (instance_count > 16) {
@@ -78515,7 +78621,12 @@ class InstancedRendererAdapter extends AbstractRenderAdapter {
      * @private
      */
     __get_instanced_mesh(sg) {
-        let im = this.__instanced_meshes.get(sg);
+        scratch_key.fromSG(sg);
+
+        // mask out some flags
+        scratch_key.flags &= INSTANCED_EQUALITY_FLAGS;
+
+        let im = this.__instanced_meshes.get(scratch_key);
 
 
         if (im !== undefined) {
@@ -78536,7 +78647,7 @@ class InstancedRendererAdapter extends AbstractRenderAdapter {
             im.mesh.castShadow = sg.getFlag(ShadedGeometryFlags.CastShadow);
             im.mesh.receiveShadow = sg.getFlag(ShadedGeometryFlags.ReceiveShadow);
 
-            this.__instanced_meshes.set(sg, im);
+            this.__instanced_meshes.set(scratch_key.clone(), im);
 
             return im;
 
@@ -78588,8 +78699,8 @@ class InstancedRendererAdapter extends AbstractRenderAdapter {
 
         const meshes = this.__active_meshes;
 
-        for (const activeMesh of meshes) {
-            activeMesh.setCount(0);
+        for (const mesh of meshes) {
+            mesh.setCount(0);
         }
 
         meshes.clear();

package/package.json

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

package/src/core/cache/Cache.js

@@ -440,6 +440,18 @@ export class Cache {
 
         this.weight = 0;
     }
+
+    /**
+     *
+     * @param {function(message:string, key:Key, value:Value)} callback
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     */
+    validate(callback, thisArg) {
+        return this.data.verifyHashes((msg, key, entry) => {
+            callback.call(thisArg, msg, key, entry.value);
+        });
+    }
 }
 
 /**

package/src/core/collection/HashMap.js

@@ -14,11 +14,13 @@ class MapEntry {
      * @param {number} hash
      */
     constructor(key, value, hash) {
+
         /**
          *
          * @type {K}
          */
         this.key = key;
+
         /**
          *
          * @type {V}
@@ -30,6 +32,7 @@ class MapEntry {
          * @type {number}
          */
         this.hash = hash;
+
     }
 }
 
@@ -45,6 +48,13 @@ const DEFAULT_INITIAL_CAPACITY = 16;
  */
 const DEFAULT_LOAD_FACTOR = 0.75;
 
+/**
+ * Multiply previous size by this number when growing the table
+ * @readonly
+ * @type {number}
+ */
+const GROWTH_FACTOR = 2;
+
 /**
  * Implements part of {@link Map} interface
  * @copyright Alex Goldring (c) 2023
@@ -69,7 +79,9 @@ export class HashMap {
         assert.isFunction(keyHashFunction, 'keyHashFunction');
         assert.isFunction(keyEqualityFunction, 'keyEqualityFunction');
         assert.isNonNegativeInteger(capacity, 'capacity');
+
         assert.isNumber(loadFactor, 'loadFactor');
+        assert.greaterThan(loadFactor, 0, 'loadFactor must be > 0');
 
         /**
          *
@@ -182,6 +194,8 @@ export class HashMap {
      * @private
      */
     __compute_bucket_index(hash) {
+        assert.isInteger(hash, 'hash');
+
         // mix the input hash to minimize potential impact of poor hash function spread
         const mixed_hash = (hash >>> 16) ^ hash;
 
@@ -245,18 +259,19 @@ export class HashMap {
 
         }
 
-        bucket.push(new MapEntry(key, value,raw_hash));
+        bucket.push(new MapEntry(key, value, raw_hash));
 
         const old_size = this.size;
         const new_size = old_size + 1;
         this.size = new_size;
 
         // compute actual current load
-        const load = new_size / this.__bucket_count;
+        const bucket_count = this.__bucket_count;
+        const load = new_size / bucket_count;
 
         if (load > this.__load_factor) {
             // current load is too high, increase table size
-            this.setBucketCount(this.__bucket_count * 2);
+            this.setBucketCount(bucket_count * GROWTH_FACTOR);
         }
     }
 
@@ -381,8 +396,11 @@ export class HashMap {
     /**
      *
      * @param {function(message:string, key:K, value:V)} callback
+     * @param {*} [thisArg]
+     * @returns {boolean}
      */
-    verifyHashes(callback) {
+    verifyHashes(callback, thisArg) {
+        let all_hashes_valid = true;
 
         let h, i;
 
@@ -408,15 +426,25 @@ export class HashMap {
                 //check hash
                 const raw_hash = this.keyHashFunction(entry.key);
 
+                if (entry.hash !== raw_hash) {
+                    callback.call(thisArg, `Hash stored on the entry(=${entry.hash}) is different from the computed key hash(=${raw_hash}).`, entry.key, entry.value)
+
+                    all_hashes_valid = false;
+                }
+
                 const actual_bucket_index = this.__compute_bucket_index(raw_hash);
 
                 const stored_bucket_index = parseInt(h);
 
                 if (actual_bucket_index !== stored_bucket_index) {
-                    callback(`Hash of key has changed. old=${stored_bucket_index}, new=${actual_bucket_index}`, entry.key, entry.value);
+                    callback.call(thisArg, `Hash of key has changed. old=${stored_bucket_index}, new=${actual_bucket_index}`, entry.key, entry.value);
+
+                    all_hashes_valid = false;
                 }
             }
         }
+
+        return all_hashes_valid;
     }
 
     /**

package/src/core/collection/HashMap.spec.js

@@ -1,10 +1,11 @@
 import { HashMap } from "./HashMap.js";
+import { passThrough, strictEquals } from "../function/Functions.js";
 
 /**
  *
  * @returns {HashMap}
  */
-function makeA() {
+function makeSample() {
     return new HashMap({
         keyHashFunction(k) {
             return 1;
@@ -16,7 +17,7 @@ function makeA() {
 }
 
 test('put and get same value', () => {
-    const m = makeA();
+    const m = makeSample();
 
     m.set("hey", 42);
 
@@ -26,7 +27,7 @@ test('put and get same value', () => {
 });
 
 test("map has a key", () => {
-    const m = makeA();
+    const m = makeSample();
 
     expect(m.has('cat')).toBe(false);
 
@@ -38,7 +39,7 @@ test("map has a key", () => {
 test("put 2 values with same hash", () => {
 
 
-    const m = makeA();
+    const m = makeSample();
 
     m.set("a", 7);
     m.set("b", 42);
@@ -48,3 +49,28 @@ test("put 2 values with same hash", () => {
     expect(m.get("a")).toBe(7);
     expect(m.get("b")).toBe(42);
 });
+
+test("retrieval works as intended after hash map grows", () => {
+    const m = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals,
+        capacity: 1,
+        loadFactor: 1
+    });
+
+    m.set(1, "a");
+
+    expect(m.get(1)).toEqual("a")
+
+    m.set(150, "b");
+
+    expect(m.get(1)).toEqual("a");
+    expect(m.get(150)).toEqual("b");
+
+    m.set(-7, "c");
+
+    expect(m.get(1)).toEqual("a");
+    expect(m.get(150)).toEqual("b");
+    expect(m.get(-7)).toEqual("c");
+
+});

package/src/core/geom/3d/apply_mat4_transform_to_direction_v3_array.js

@@ -0,0 +1,49 @@
+/**
+ * Matrix-transform an array of 3d direction vectors
+ * Code is inlined for speed
+ * @param {number[]|Float32Array|Float64Array} source
+ * @param {number} source_offset
+ * @param {number[]|Float32Array|Float64Array} destination
+ * @param {number} destination_offset
+ * @param {number} vertex_count
+ * @param {mat4|number[]|Float32Array} mat4
+ */
+export function apply_mat4_transform_to_direction_v3_array(source, source_offset, destination, destination_offset, vertex_count, mat4) {
+
+    const a0 = mat4[0];
+    const a1 = mat4[1];
+    const a2 = mat4[2];
+
+    const b0 = mat4[4];
+    const b1 = mat4[5];
+    const b2 = mat4[6];
+
+    const c0 = mat4[8];
+    const c1 = mat4[9];
+    const c2 = mat4[10];
+
+    for (let i = 0; i < vertex_count; i++) {
+        const i3 = i * 3;
+
+        const source_vertex_address = source_offset + i3;
+
+        const _x = source[source_vertex_address];
+        const _y = source[source_vertex_address + 1];
+        const _z = source[source_vertex_address + 2];
+
+        const x = a0 * _x + b0 * _y + c0 * _z;
+        const y = a1 * _x + b1 * _y + c1 * _z;
+        const z = a2 * _x + b2 * _y + c2 * _z;
+
+        const normal_multiplier = 1 / Math.hypot(x, y, z);
+
+        const destination_vertex_address = destination_offset + i3;
+
+        destination[destination_vertex_address] = x * normal_multiplier;
+        destination[destination_vertex_address + 1] = y * normal_multiplier;
+        destination[destination_vertex_address + 2] = z * normal_multiplier;
+
+
+    }
+
+}

package/src/core/geom/3d/apply_mat4_transform_to_v3_array.js

@@ -5,10 +5,10 @@
  * @param {number} source_offset
  * @param {number[]|Float32Array|Float64Array} destination
  * @param {number} destination_offset
- * @param {number} count
+ * @param {number} vertex_count
  * @param {mat4|number[]|Float32Array} mat4
  */
-export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, count, mat4) {
+export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, vertex_count, mat4) {
 
     const a0 = mat4[0];
     const a1 = mat4[1];
@@ -26,7 +26,7 @@ export function apply_mat4_transform_to_v3_array(source, source_offset, destinat
     const d1 = mat4[13];
     const d2 = mat4[14];
 
-    for (let i = 0; i < count; i++) {
+    for (let i = 0; i < vertex_count; i++) {
         const i3 = i * 3;
 
         const source_vertex_address = source_offset + i3;
@@ -49,3 +49,4 @@ export function apply_mat4_transform_to_v3_array(source, source_offset, destinat
     }
 
 }
+

package/src/core/model/node-graph/node/NodeDescription.js

@@ -83,6 +83,15 @@ export class NodeDescription {
         };
     }
 
+    /**
+     * Perform additional processing on the node instance
+     * This gives us an opportunity to add/change ports based on current state of a specific node instance
+     * @param {NodeInstance} instance
+     */
+    configureNode(instance){
+        // override in subclasses as necessary
+    }
+
     /**
      * Output ports
      * @returns {Port[]}

package/src/core/model/node-graph/node/NodeInstance.js

@@ -32,7 +32,6 @@ export class NodeInstance {
          */
         this.endpoints = [];
 
-
         /**
          * Internal instance data
          * @type {Object}
@@ -51,6 +50,14 @@ export class NodeInstance {
          */
         this.connections = new List();
 
+        /**
+         * Extra ports that are present just on this instance, these exist in addition to ports from the description
+         * IDs of these ports must not collide with IDs of ports on the description
+         * @protected
+         * @type {Port[]}
+         */
+        this.dynamicPorts = [];
+
         /**
          * @readonly
          */
@@ -254,6 +261,8 @@ export class NodeInstance {
     setDescription(node) {
         this.description = node;
 
+        node.configureNode(this);
+
         //generate endpoints
         this.endpoints = node.getPorts().map((port, port_index) => {
             const endpoint = new NodeInstancePortReference();

package/src/engine/asset/loaders/material/StaticMaterialCache.js

@@ -96,6 +96,24 @@ export class StaticMaterialCache {
         return material;
 
     }
+
+    /**
+     *
+     * @param {function(string)} error_consumer
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     */
+    validate(error_consumer, thisArg) {
+        const materials_valid = this.materialCache.validate((message, key, value) => {
+            error_consumer.call(thisArg, `Material error: ${message}. Material ${key}`);
+        });
+        const textures_valid = this.textureCache.validate((message, key, value) => {
+            error_consumer.call(thisArg, `Texture error: ${message}. Texture ${key}`);
+        });
+
+        return materials_valid
+            && textures_valid;
+    }
 }
 
 /**