@woosh/meep-engine 2.34.15 → 2.34.16

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