@woosh/meep-engine 2.47.31 → 2.47.33

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.31",
+  "version": "2.47.33",
   "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/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;
+    }
 }
 
 /**

package/src/engine/graphics/ecs/mesh-v2/render/adapters/InstancedRendererAdapter.js

@@ -3,43 +3,34 @@ import { HashMap } from "../../../../../../core/collection/HashMap.js";
 import { InstancedMeshGroup } from "../../../../geometry/instancing/InstancedMeshGroup.js";
 import { ShadedGeometryFlags } from "../../ShadedGeometryFlags.js";
 import { StreamDrawUsage } from "three";
+import { SGCacheKey } from "./SGCacheKey.js";
 
 const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
 
+/**
+ * @readonly
+ * @type {SGCacheKey}
+ */
+const scratch_key = new SGCacheKey();
+
 export 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 {Set<InstancedMeshGroup>}
-         * @private
-         */
-        this.__active_meshes = new Set();
-    }
+    /**
+     *
+     * @type {HashMap<SGCacheKey, InstancedMeshGroup>}
+     * @private
+     */
+    __instanced_meshes = new HashMap();
+
+    /**
+     *
+     * @type {Set<InstancedMeshGroup>}
+     * @private
+     */
+    __active_meshes = new Set();
+
 
     score(geometry, material, instance_count) {
         if (instance_count > 16) {
@@ -58,7 +49,12 @@ export 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) {
@@ -79,7 +75,7 @@ export 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;
 
@@ -131,8 +127,8 @@ export 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/src/engine/graphics/ecs/mesh-v2/render/adapters/SGCacheKey.js

@@ -0,0 +1,59 @@
+import { DrawMode } from "../../DrawMode.js";
+
+export 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;
+    }
+}