@woosh/meep-engine 2.65.0 → 2.66.0

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -12,21 +12,20 @@ import {
     Sphere as ThreeSphere,
     Vector3 as ThreeVector3
 } from 'three';
-
-import IndexedBinaryBVH from '../../../../core/bvh2/binary/IndexedBinaryBVH.js';
-
-
-import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
+import { BinaryUint32BVH } from "../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+import { bvh32_query_user_data_ray } from "../../../../core/bvh2/binary/2/bvh32_query_user_data_ray.js";
+import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import Signal from "../../../../core/events/signal/Signal.js";
-import { passThrough } from "../../../../core/function/Functions.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import Vector2 from '../../../../core/geom/Vector2.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
 import ObservedInteger from "../../../../core/model/ObservedInteger.js";
-import { BVHGeometryRaycaster } from "../../../graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js";
 
 import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
 
@@ -34,6 +33,12 @@ import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
 const EMPTY_GEOMETRY = new ThreeBufferGeometry();
 const DEFAULT_MATERIAL = new MeshBasicMaterial();
 
+const scratch_array = []
+const scratch_hit = new SurfacePoint3()
+
+const ray_tmp = [];
+const m4_tmp = [];
+
 /**
  * terrain tile is a part of a 2d array
  */
@@ -66,13 +71,13 @@ class TerrainTile {
 
     /**
      *
-     * @type {LeafNode}
+     * @type {BvhClient}
      */
-    boundingBox = new LeafNode(this);
+    external_bvh = new BvhClient();
 
     /**
      *
-     * @type {BinaryNode}
+     * @type {BinaryUint32BVH}
      */
     bvh = null;
 
@@ -121,8 +126,6 @@ class TerrainTile {
      */
     __initial_height_range = new NumericInterval(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
 
-    raycaster = new BVHGeometryRaycaster();
-
     constructor() {
 
         this.mesh.name = "TerrainTile";
@@ -132,9 +135,6 @@ class TerrainTile {
          * @type {boolean}
          */
         this.mesh.matrixWorldNeedsUpdate = false;
-
-        //Binary BVH form doesn't have distinct leaf objects and stores face indices directly, this requires a special face index extractor that treats leaves as indices directly.
-        this.raycaster.extractFaceIndexFromLeaf = passThrough;
     }
 
     /**
@@ -152,32 +152,6 @@ class TerrainTile {
     set transform(m4) {
         array_copy(m4, 0, this.mesh.matrixWorld.elements, 0, 16);
         this.computeBoundingBox();
-
-        // raycaster needs to store transform as well
-        array_copy(m4, 0, this.raycaster.transform, 0, 16);
-    }
-
-    /**
-     *
-     * @param {Vector3} origin
-     * @param {Vector3} direction
-     * @param {function} callback
-     * @param {function} missCallback
-     */
-    raycast(origin, direction, callback, missCallback) {
-        const hitFound = this.raycaster.raycast(
-            hit,
-            origin.x, origin.y, origin.z,
-            direction.x, direction.y, direction.z
-        );
-
-        if (hitFound) {
-            callback(hit.position, hit.normal);
-        } else {
-            missCallback();
-        }
-
-        return hitFound;
     }
 
     /**
@@ -191,11 +165,87 @@ class TerrainTile {
      * @param {number} directionZ
      * @return {boolean}
      */
-    raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ) {
+    raycastFirstSync(
+        result,
+        originX, originY, originZ,
+        directionX, directionY, directionZ
+    ) {
+
+        const m4 = this.transform;
+
+        mat4.invert(m4_tmp, m4);
+
+        ray3_array_compose(
+            ray_tmp,
+            originX, originY, originZ,
+            directionX, directionY, directionZ
+        );
 
-        const r = this.raycaster.raycast(result, originX, originY, originZ, directionX, directionY, directionZ);
+        ray3_array_apply_matrix4(ray_tmp, 0, ray_tmp, 0, m4_tmp);
+
+        const _originX = ray_tmp[0];
+        const _originY = ray_tmp[1];
+        const _originZ = ray_tmp[2];
+
+        const _directionX = ray_tmp[3];
+        const _directionY = ray_tmp[4];
+        const _directionZ = ray_tmp[5];
+
+        const hit_count = bvh32_query_user_data_ray(
+            this.bvh,
+            scratch_array, 0,
+            _originX, _originY, _originZ,
+            _directionX, _directionY, _directionZ
+        );
+
+        let best_distance = Infinity;
+        let hit_found = false;
+
+        const geometry = this.geometry;
 
-        return r;
+        const geometryIndices = geometry.getIndex().array;
+        const geometryPositions = geometry.getAttribute('position').array;
+
+        for (let i = 0; i < hit_count; i++) {
+            const triangle_index = scratch_array[i];
+
+            const index3 = triangle_index * 3;
+
+            const a = geometryIndices[index3] * 3;
+            const b = geometryIndices[index3 + 1] * 3;
+            const c = geometryIndices[index3 + 2] * 3;
+
+            const triangle_hit_found = computeTriangleRayIntersection(
+                scratch_hit,
+                _originX, _originY, _originZ,
+                _directionX, _directionY, _directionZ,
+                geometryPositions[a], geometryPositions[a + 1], geometryPositions[a + 2],
+                geometryPositions[b], geometryPositions[b + 1], geometryPositions[b + 2],
+                geometryPositions[c], geometryPositions[c + 1], geometryPositions[c + 2],
+            )
+
+            if (!triangle_hit_found) {
+                continue;
+            }
+
+            hit_found = true;
+
+            const distance_sqr = scratch_hit.position._distanceSqrTo(_originX, _originY, _originZ);
+
+            if (distance_sqr < best_distance) {
+                best_distance = distance_sqr;
+                result.copy(scratch_hit);
+            }
+        }
+
+        if (hit_found) {
+            result.applyMatrix4(m4);
+
+            // make sure to pull normal to magnitude of 1
+            result.normal.normalize();
+        }
+
+        return hit_found;
     }
 
     getVertexNormal(index, result) {
@@ -468,16 +518,27 @@ class TerrainTile {
 
             //check for bvh
             const bvh = this.bvh;
+
             if (bvh !== null) {
-                geometry.boundingBox = new ThreeBox3(new ThreeVector3(bvh.x0, bvh.y0, bvh.z0), new ThreeVector3(bvh.x1, bvh.y1, bvh.z1));
+                const float32 = bvh.float32;
+
+                const x0 = float32[0];
+                const y0 = float32[1];
+                const z0 = float32[2];
+
+                const x1 = float32[3];
+                const y1 = float32[4];
+                const z1 = float32[5];
 
-                const dX = bvh.x1 - bvh.x0;
-                const dY = bvh.y1 - bvh.y0;
-                const dZ = bvh.z1 - bvh.z0;
+                geometry.boundingBox = new ThreeBox3(new ThreeVector3(x0, y0, z0), new ThreeVector3(x1, y1, z1));
+
+                const dX = x1 - x0;
+                const dY = y1 - y0;
+                const dZ = z1 - z0;
 
                 const radius = Math.sqrt(dX * dX + dY * dY + dZ * dZ) / 2;
 
-                const center = new ThreeVector3(bvh.x0 + dX / 2, bvh.y0 + dY / 2, bvh.z0 + dZ / 2);
+                const center = new ThreeVector3(x0 + dX / 2, y0 + dY / 2, z0 + dZ / 2);
 
                 geometry.boundingSphere = new ThreeSphere(center, radius);
             }
@@ -505,12 +566,10 @@ class TerrainTile {
 
         geometry_bb.applyMatrix4(this.transform);
 
-        this.boundingBox.setBounds(
+        this.external_bvh.resize(
             geometry_bb.x0, geometry_bb.y0, geometry_bb.z0,
             geometry_bb.x1, geometry_bb.y1, geometry_bb.z1
         );
-        // update changes up the tree
-        this.boundingBox.bubbleRefit();
     }
 
     /**
@@ -536,6 +595,11 @@ class TerrainTile {
         this.onDestroyed.send1(this);
     }
 
+    /**
+     *
+     * @param {{geometry, bvh?:{leaf_count:number, data:ArrayBuffer}}} tileData
+     * @returns {Mesh}
+     */
     build(tileData) {
         this.isBuilt = true;
         // console.groupCollapsed('Building tile');
@@ -557,12 +621,12 @@ class TerrainTile {
         if (this.enableBVH) {
             // console.time('bvh');
             // this.generateBufferedGeometryBVH();
-            const bvh = this.bvh = new IndexedBinaryBVH();
-            for (let p in tileData.bvh) {
-                if (tileData.bvh.hasOwnProperty(p)) {
-                    bvh[p] = tileData.bvh[p];
-                }
-            }
+            const bvh = this.bvh = new BinaryUint32BVH();
+            const serialized_bvh = tileData.bvh;
+
+            bvh.setLeafCount(serialized_bvh.leaf_count);
+            bvh.data = serialized_bvh.data;
+
             // console.timeEnd('bvh');
         }
 
@@ -582,17 +646,8 @@ class TerrainTile {
         // console.timeEnd('total');
         // console.groupEnd();
 
-        this.raycaster.bvh = this.bvh;
-        this.raycaster.geometry = g;
-        this.raycaster.position = this.position;
-        this.raycaster.scale = this.scale;
-        this.raycaster.resolution = this.resolution.getValue();
-        this.raycaster.size = this.size;
-
         return mesh;
     }
 }
 
-const hit = new SurfacePoint3();
-
 export default TerrainTile;