@woosh/meep-engine 2.47.32 → 2.47.34

package/build/meep.cjs

@@ -60435,11 +60435,13 @@ class MapEntry {
      * @param {number} hash
      */
     constructor(key, value, hash) {
+
         /**
          *
          * @type {K}
          */
         this.key = key;
+
         /**
          *
          * @type {V}
@@ -60451,6 +60453,7 @@ class MapEntry {
          * @type {number}
          */
         this.hash = hash;
+
     }
 }
 
@@ -60466,6 +60469,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
@@ -60490,7 +60500,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');
 
         /**
          *
@@ -60603,6 +60615,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;
 
@@ -60666,18 +60680,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);
         }
     }
 
@@ -60802,8 +60817,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;
 
@@ -60829,15 +60847,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;
     }
 
     /**
@@ -61501,6 +61529,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);
+        });
+    }
 }
 
 /**
@@ -77811,6 +77851,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;
+    }
 }
 
 /**
@@ -78463,42 +78521,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) {
@@ -78517,7 +78623,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) {
@@ -78538,7 +78649,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;
 
@@ -78590,8 +78701,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();