@woosh/meep-engine 2.34.14 → 2.34.15

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

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {THREE.Color} c
+ */
+export function computeHashColor(c) {
+    return c.getHex();
+}

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

@@ -1,9 +1,9 @@
 import { planesEqual } from "./planesEqual.js";
-import { computeTextureEquality } from "./computeTextureEquality.js";
 import { isArraysEqualWithComparator } from "../../../../core/collection/array/isArraysEqualWithComparator.js";
+import { computeTextureEqualityById } from "./computeTextureEqualityById.js";
 
 /**
- *
+ * NOTE: does not do deep comparison on textures, only checks the IDs
  * @param {Material|MeshStandardMaterial|MeshDepthMaterial|MeshMatcapMaterial} a
  * @param {Material|MeshStandardMaterial|MeshDepthMaterial|MeshMatcapMaterial} b
  * @returns {boolean}
@@ -76,28 +76,28 @@ export function computeMaterialEquality(a, b) {
             || a.wireframeLinewidth !== b.wireframeLinewidth
             || a.morphTargets !== b.morphTargets
             || a.morphNormals !== b.morphNormals
-            || !computeTextureEquality(a.roughnessMap, b.roughnessMap)
-            || !computeTextureEquality(a.metalnessMap, b.metalnessMap)
-            || !computeTextureEquality(a.alphaMap, b.alphaMap)
-            || !computeTextureEquality(a.envMap, b.envMap)
-            || !computeTextureEquality(a.displacementMap, b.displacementMap)
-            || !computeTextureEquality(a.normalMap, b.normalMap)
-            || !computeTextureEquality(a.emissiveMap, b.emissiveMap)
-            || !computeTextureEquality(a.bumpMap, b.bumpMap)
-            || !computeTextureEquality(a.aoMap, b.aoMap)
-            || !computeTextureEquality(a.map, b.map)
-            || !computeTextureEquality(a.lightMap, b.lightMap)
+            || !computeTextureEqualityById(a.roughnessMap, b.roughnessMap)
+            || !computeTextureEqualityById(a.metalnessMap, b.metalnessMap)
+            || !computeTextureEqualityById(a.alphaMap, b.alphaMap)
+            || !computeTextureEqualityById(a.envMap, b.envMap)
+            || !computeTextureEqualityById(a.displacementMap, b.displacementMap)
+            || !computeTextureEqualityById(a.normalMap, b.normalMap)
+            || !computeTextureEqualityById(a.emissiveMap, b.emissiveMap)
+            || !computeTextureEqualityById(a.bumpMap, b.bumpMap)
+            || !computeTextureEqualityById(a.aoMap, b.aoMap)
+            || !computeTextureEqualityById(a.map, b.map)
+            || !computeTextureEqualityById(a.lightMap, b.lightMap)
         ) {
             return false;
         }
     } else if (a.isMeshDepthMaterial) {
         if (
-            !computeTextureEquality(a.alphaMap, b.alphaMap)
+            !computeTextureEqualityById(a.alphaMap, b.alphaMap)
             || a.depthPacking !== b.depthPacking
-            || !computeTextureEquality(a.displacementMap, b.displacementMap)
+            || !computeTextureEqualityById(a.displacementMap, b.displacementMap)
             || a.displacementScale !== b.displacementScale
             || a.displacementBias !== b.displacementBias
-            || !computeTextureEquality(a.map, b.map)
+            || !computeTextureEqualityById(a.map, b.map)
             || a.morphTargets !== b.morphTargets
             || a.wireframe !== b.wireframe
             || a.wireframeLinewidth !== b.wireframeLinewidth
@@ -107,15 +107,15 @@ export function computeMaterialEquality(a, b) {
     } else if (a.isMeshMatcapMaterial) {
         if (
             !a.color.equals(b.color)
-            || !computeTextureEquality(a.matcap, b.matcap)
-            || !computeTextureEquality(a.map, b.map)
-            || !computeTextureEquality(a.bumpMap, b.bumpMap)
-            || !computeTextureEquality(a.normalMap, b.normalMap)
+            || !computeTextureEqualityById(a.matcap, b.matcap)
+            || !computeTextureEqualityById(a.map, b.map)
+            || !computeTextureEqualityById(a.bumpMap, b.bumpMap)
+            || !computeTextureEqualityById(a.normalMap, b.normalMap)
             || !a.normalScale.equals(b.normalScale)
-            || !computeTextureEquality(a.displacementMap, b.displacementMap)
+            || !computeTextureEqualityById(a.displacementMap, b.displacementMap)
             || a.displacementScale !== b.displacementScale
             || a.displacementBias !== b.displacementBias
-            || !computeTextureEquality(a.alphaMap, b.alphaMap)
+            || !computeTextureEqualityById(a.alphaMap, b.alphaMap)
             || a.morphTargets !== b.morphTargets
             || a.morphNormals !== b.morphNormals
             || a.flatShading !== b.flatShading

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

@@ -1,9 +1,10 @@
 import { planeHash } from "./planeHash.js";
-import { computeTextureHash } from "./computeTextureHash.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { computeHashArray } from "../../../../core/collection/array/computeHashArray.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { textureHashById } from "./textureHashById.js";
+import { computeHashColor } from "./computeHashColor.js";
 
 /**
  *
@@ -46,21 +47,22 @@ export function computeMaterialHash(material) {
 
 
     if (material.isMeshStandardMaterial) {
-        //TODO extend hash
         hash = computeHashIntegerArray(
             hash,
-            computeTextureHash(material.map),
-            computeTextureHash(material.lightMap),
-            computeTextureHash(material.aoMap),
-            computeTextureHash(material.emissiveMap),
-            computeTextureHash(material.bumpMap),
-            computeTextureHash(material.normalMap),
-            computeTextureHash(material.displacementMap),
-            computeTextureHash(material.roughnessMap),
-            computeTextureHash(material.metalnessMap),
-            computeTextureHash(material.alphaMap),
+            computeHashColor(material.color),
+            computeHashFloat(material.roughness),
+            computeHashFloat(material.metalness),
+            textureHashById(material.map),
+            textureHashById(material.lightMap),
+            computeHashFloat(material.lightMapIntensity),
+            textureHashById(material.aoMap),
+            computeHashFloat(material.aoMapIntensity),
+            computeHashColor(material.emissive),
+            computeHashFloat(material.emissiveIntensity),
+            textureHashById(material.emissiveMap),
             computeHashFloat(material.envMapIntensity),
-            computeTextureHash(material.envMap)
+            textureHashById(material.bumpMap),
+            textureHashById(material.normalMap),
         );
     } else if (material.isShaderMaterial) {
         hash ^= material.lights ? 0 : 1;

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

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {Texture} a
+ * @param {Texture} b
+ * @returns {boolean}
+ */
+export function computeTextureEqualityById(a, b) {
+    if (a === b) {
+        return true;
+    }
+
+    if (
+        a === null
+        || b === null
+        || a === undefined
+        || b === undefined
+    ) {
+        return false;
+    }
+
+    return a.id === b.id;
+}

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

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {THREE.Texture} texture
+ * @return {number}
+ */
+export function textureHashById(texture) {
+    if (texture === undefined || texture === null) {
+        return 0;
+    }
+
+    return texture.id;
+}

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.14",
+  "version": "2.34.15",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",