@woosh/meep-engine 2.34.11 → 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/engine/graphics/texture/sampler/Sampler2D.d.ts

@@ -1,5 +1,26 @@
 export class Sampler2D {
+    readonly height: number
+    readonly width: number
+
+    readonly itemSize: number
+
     readChannel(x: number, y: number, channel: number): number
 
     writeChannel(x: number, y: number, channel: number, value: number): void
+
+    static uint8clamped(itemSize: number, width: number, height: number): Sampler2D
+
+    static uint8(itemSize: number, width: number, height: number): Sampler2D
+
+    static uint16(itemSize: number, width: number, height: number): Sampler2D
+
+    static uint32(itemSize: number, width: number, height: number): Sampler2D
+
+    static int8(itemSize: number, width: number, height: number): Sampler2D
+
+    static int16(itemSize: number, width: number, height: number): Sampler2D
+
+    static int32(itemSize: number, width: number, height: number): Sampler2D
+
+    static float32(itemSize: number, width: number, height: number): Sampler2D
 }

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -133,7 +133,7 @@ function sampleTriangleBottomRight(p1, p2, p3, dx, dy) {
 
 /**
  *
- * @param {Array.<Number>|Uint8ClampedArray|Uint8Array|Uint16Array|Int8Array|Float32Array} data
+ * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
  * @param {int} itemSize
  * @param {int} width
  * @param {int} height
@@ -255,6 +255,18 @@ Sampler2D.int16 = function (itemSize, width, height) {
     const sampler = new Sampler2D(data, itemSize, width, height);
     return sampler;
 };
+/**
+ *
+ * @param {int} itemSize
+ * @param {int} width
+ * @param {int} height
+ * @return {Sampler2D}
+ */
+Sampler2D.int32 = function (itemSize, width, height) {
+    const data = new Int32Array(width * height * itemSize);
+    const sampler = new Sampler2D(data, itemSize, width, height);
+    return sampler;
+};
 
 /**
  *
@@ -268,6 +280,18 @@ Sampler2D.float32 = function (itemSize, width, height) {
     const sampler = new Sampler2D(data, itemSize, width, height);
     return sampler;
 };
+/**
+ *
+ * @param {int} itemSize
+ * @param {int} width
+ * @param {int} height
+ * @return {Sampler2D}
+ */
+Sampler2D.float64 = function (itemSize, width, height) {
+    const data = new Float64Array(width * height * itemSize);
+    const sampler = new Sampler2D(data, itemSize, width, height);
+    return sampler;
+};
 
 /**
  *

package/generation/grid/GridData.d.ts

@@ -0,0 +1,3 @@
+export class GridData{
+
+}

package/generation/grid/GridTaskGenerator.js

@@ -54,7 +54,7 @@ export class GridTaskGenerator {
      * @returns {Task|TaskGroup}
      */
     build(grid, ecd, seed) {
-
+        throw new Error('Not Implemented');
     }
 }
 

package/generation/grid/generation/NoopGridTaskGenerator.js

@@ -0,0 +1,8 @@
+import { GridTaskGenerator } from "../GridTaskGenerator.js";
+import { emptyTask } from "../../../core/process/task/TaskUtils.js";
+
+export class NoopGridTaskGenerator extends GridTaskGenerator {
+    build(grid, ecd, seed) {
+        return emptyTask('empty');
+    }
+}

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.11",
+  "version": "2.34.15",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",