@woosh/meep-engine 2.33.25 → 2.33.29

package/engine/asset/loaders/material/computeTextureEquality.js

@@ -1,4 +1,5 @@
 import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 
 //
 
@@ -50,20 +51,10 @@ export function computeTextureEquality(a, b) {
         const aMipmaps = a.mipmaps;
         const bMipmaps = b.mipmaps;
 
-        const n = aMipmaps.length;
-
-        if (n !== bMipmaps.length) {
+        if (!textureMipChainEqual(aMipmaps, bMipmaps)) {
             return false;
         }
 
-        for (let i = 0; i < n; i++) {
-            const aMipmap = aMipmaps[i];
-            const bMipmap = bMipmaps[i];
-
-            if (!textureMipmapEqual(aMipmap, bMipmap)) {
-                return false;
-            }
-        }
     }
 
     //TODO implement support for other texture types
@@ -119,47 +110,52 @@ export function textureImagesEqual(a, b) {
             const bMipmaps = bi.mipmaps;
 
             //TODO should we ignore mipmaps if they are absent?
-            if (aMipmaps === undefined) {
-                if (bMipmaps === undefined) {
-                    continue;
-                } else {
-                    return false;
-                }
-            } else if (bMipmaps === undefined) {
+            if (!textureMipChainEqual(aMipmaps, bMipmaps)) {
                 return false;
             }
+        }
+
+    }
 
-            for (let j = 0; j < aMipmaps.length; j++) {
-                const aMipmap = aMipmaps[j];
-                const bMipmap = bMipmaps[j];
+    // assume equivalent
+    return true;
+}
+
+/**
+ *
+ * @param {[]} a
+ * @param {[]} b
+ * @returns {boolean}
+ */
+function textureMipChainEqual(a, b) {
+    if (a === undefined) {
+        if (b === undefined) {
+            return true;
+        } else {
+            return false;
+        }
+    } else if (b === undefined) {
+        return false;
+    }
 
-                /**
-                 * @type {Uint8Array}
-                 */
-                const aData = aMipmap.data;
+    const a_length = a.length;
 
-                /**
-                 * @type {Uint8Array}
-                 */
-                const bData = bMipmap.data;
+    if (a_length !== b.length) {
+        // different mip chain length
+        return false;
+    }
 
-                const dataLength = aData.length;
-                if (dataLength !== bData.length) {
-                    return false;
-                }
+    for (let j = a_length - 1; j >= 0; j--) { //traverse chain top to bottom, starting from smallest mip for faster rejection
 
+        const aMipmap = a[j];
+        const bMipmap = b[j];
 
-                for (let k = 0; k < dataLength; k++) {
-                    if (aData[k] !== bData[k]) {
-                        return false;
-                    }
-                }
-            }
+        if (!textureMipmapEqual(aMipmap, bMipmap)) {
+            return false;
         }
 
     }
 
-    // assume equivalent
     return true;
 }
 
@@ -182,16 +178,11 @@ function textureMipmapEqual(a, b) {
     const aData = a.data;
     const bData = b.data;
 
-    const n = aData.length;
-    if (bData.length !== n) {
-        return false;
-    }
 
-    for (let i = 0; i < n; i++) {
-        if (aData[i] !== bData[i]) {
-            return false;
-        }
+    if (aData === bData) {
+        // special case
+        return true;
     }
 
-    return true;
+    return isArrayEqualStrict(aData, bData);
 }

package/engine/ecs/EntityComponentDataset.js

@@ -1212,7 +1212,7 @@ export class EntityComponentDataset {
 
         if (!ENV_PRODUCTION) {
             assert.isNumber(componentTypeIndex, "componentTypeIndex");
-            assert.typeOf(visitor, "function", "visitor");
+            assert.isFunction(visitor, "visitor");
         }