@woosh/meep-engine 2.34.13 → 2.34.17

package/core/bvh2/aabb3/aabb3_array_intersects_ray.js

@@ -0,0 +1,20 @@
+//
+
+import { intersectRay } from "./AABB3Math.js";
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]|Float32Array} aabb bounding box, order: x0,y0,z0,x1,y1,z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ */
+export function aabb3_array_intersects_ray(aabb, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
+    return intersectRay(aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5],
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z
+    );
+}

package/core/bvh2/binary/IndexedBinaryBVH.js

@@ -140,7 +140,23 @@ export default class IndexedBinaryBVH {
     }
 
     /**
-     *
+     * Sets bounds of a given leaf
+     * NOTE: to build tree, must call {@link #unsortedBuiltIntermediate} after all leaves are set
+     * @param {number} leaf_index
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     */
+    writeLeaf(leaf_index, x0, y0, z0, x1, y1, z1) {
+        const offset = this.binaryNodeCount * 6 + leaf_index * 6;
+        writeBox(this.data, offset, x0, y0, z0, x1, y1, z1);
+    }
+
+    /**
+     * @deprecated use {@link #writeLeaf} instead followed by {@link #unsortedBuiltIntermediate}
      * @param {function(index:number,offset:number,data:*, writeBox:function):*} visitor
      */
     setLeafs(visitor) {

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/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts

@@ -8,4 +8,11 @@ export class GeometrySpatialQueryAccelerator {
     queryContainmentViaClippingPlanes(geometry: BufferGeometry, planes: Plane[]): number
 
     queryRaycastNearest(destination: SurfacePoint3, geometry: BufferGeometry, ray_origin: Vector3, ray_direction: Vector3): boolean
+
+    queryRaycastNearest_primitive(
+        destination: SurfacePoint3,
+        geometry: BufferGeometry,
+        origin_x: number, origin_y: number, origin_z: number,
+        direction_x: number, direction_y: number, direction_z: number
+    ): boolean
 }

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -3,6 +3,7 @@ import { buildUnsorted } from "../../bvh/buffered/BinaryBVHFromBufferGeometry.js
 import { ClippingPlaneContainmentComputingVisitor } from "./ClippingPlaneContainmentComputingVisitor.js";
 import { RaycastNearestHitComputingVisitor } from "./RaycastNearestHitComputingVisitor.js";
 import { assert } from "../../../../../core/assert.js";
+import { deinterleaveBufferAttribute } from "../deinterleaveBufferAttribute.js";
 
 export class GeometrySpatialQueryAccelerator {
     constructor(cache_size = 100 * 1024 * 1024) {
@@ -153,8 +154,14 @@ export class GeometrySpatialQueryAccelerator {
      * @returns {IndexedBinaryBVH}
      */
     __buildBVH(geometry) {
-        const vertices = geometry.getAttribute('position').array;
-        const indices = geometry.getIndex().array;
+        const position_attribute = geometry.getAttribute('position');
+        const index_attribute = geometry.getIndex();
+
+        const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
+        const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);
+
+        const vertices = de_interleaved_position_attribute.array;
+        const indices = de_interleaved_index_attribute.array;
 
         return buildUnsorted(vertices, indices);
     }

package/engine/graphics/geometry/bvh/buffered/BinaryBVHFromBufferGeometry.js

@@ -1,10 +1,9 @@
 /**
  * Created by Alex on 29/05/2016.
  */
-import IndexedTriangleBoundsComputer from './IndexedTraingleBoundsComputer.js';
 import IndexedBinaryBVH from '../../../../../core/bvh2/binary/IndexedBinaryBVH.js';
-
-const makeTriangle = IndexedTriangleBoundsComputer.compute;
+import { min3 } from "../../../../../core/math/min3.js";
+import { max3 } from "../../../../../core/math/max3.js";
 
 /**
  *
@@ -19,20 +18,46 @@ function buildUnsorted(vertices, indices) {
     const tree = new IndexedBinaryBVH();
     tree.initialize(numNodes);
 
-    tree.setLeafs(function (i, offset, data, writeBox) {
+    for (let i = 0; i < numNodes; i++) {
 
         const index3 = i * 3;
 
+        // read triangle vertex indices
         const iA = indices[index3];
         const iB = indices[index3 + 1];
         const iC = indices[index3 + 2];
 
-        makeTriangle(iA * 3, iB * 3, iC * 3, vertices, function (x0, y0, z0, x1, y1, z1) {
-            writeBox(data, offset, x0, y0, z0, x1, y1, z1);
-        });
+        const a = iA * 3;
+        const b = iB * 3;
+        const c = iC * 3;
+
+        // read actual positions of each vertex
+        const aX = vertices[a];
+        const aY = vertices[a + 1];
+        const aZ = vertices[a + 2];
+
+        const bX = vertices[b];
+        const bY = vertices[b + 1];
+        const bZ = vertices[b + 2];
+
+        const cX = vertices[c];
+        const cY = vertices[c + 1];
+        const cZ = vertices[c + 2];
+
+        // compute bounds of the triangle
+        const x0 = min3(aX, bX, cX);
+        const y0 = min3(aY, bY, cY);
+        const z0 = min3(aZ, bZ, cZ);
+
+        const x1 = max3(aX, bX, cX);
+        const y1 = max3(aY, bY, cY);
+        const z1 = max3(aZ, bZ, cZ);
+
+        tree.writeLeaf(i, x0, y0, z0, x1, y1, z1);
+    }
 
-        return i;
-    });
+    // finalize build
+    tree.unsortedBuiltIntermediate();
 
     return tree;
 }

package/engine/graphics/micron/format/MicronGeometry.js

@@ -1,11 +1,17 @@
 import { VertexDataSpec } from "../../geometry/VertexDataSpec.js";
 import { assert } from "../../../../core/assert.js";
-import { intersectRay } from "../../../../core/bvh2/aabb3/AABB3Math.js";
 import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
 
 let id_counter = 0;
 
+/**
+ * @readonly
+ * @type {MicronGeometryPatch[]}
+ */
+const scratch_traversal_stack = [];
+
 export class MicronGeometry {
     constructor() {
         /**
@@ -79,8 +85,10 @@ export class MicronGeometry {
          */
         const hits = [];
 
+        // initialize stack
         let stack_cursor = 1;
-        const stack = [this.root];
+        const stack = scratch_traversal_stack;
+        stack[0] = this.root;
 
         const spec = this.vertex_spec;
 
@@ -99,8 +107,8 @@ export class MicronGeometry {
             // using group bounding box because it's conservative, as we want to be able to hit LOD_0
             const bb = patch.group_bounding_box;
 
-            const bb_intersection_exists = intersectRay(
-                bb[0], bb[1], bb[2], bb[3], bb[4], bb[5],
+            const bb_intersection_exists = aabb3_array_intersects_ray(
+                bb,
                 origin_x, origin_y, origin_z,
                 direction_x, direction_y, direction_z
             );
@@ -113,6 +121,15 @@ export class MicronGeometry {
             if (patch.lod === 0) {
                 // LOD 0 - source geometry
 
+                // cast against bounds
+                if (!aabb3_array_intersects_ray(
+                    patch.bounding_box,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z
+                )) {
+                    continue;
+                }
+
                 // raycast against geometry
                 const indices = patch.face_indices;
                 const index_count = indices.length;

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