@woosh/meep-engine 2.68.0 → 2.69.0

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.68.0",
+  "version": "2.69.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -100,34 +100,41 @@ export class BinaryUint32BVH {
      */
     __data_uint32;
 
-    constructor() {
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node_count_binary = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_binary = 0;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node_count_leaf = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_leaf = 0;
 
+    constructor() {
         this.data = new ArrayBuffer(320);
     }
 
+    /**
+     * In bytes
+     * @returns {number}
+     */
+    estimateByteSize() {
+        return this.data.byteLength + 248;
+    }
+
     getTotalBoxCount() {
         return this.__node_count_binary + this.__node_count_leaf;
     }
 
-    getBinaryNodeCount() {
+    get binary_node_count() {
         return this.__node_count_binary;
     }
 
-    getLeafNodeCount() {
+    get leaf_node_count() {
         return this.__node_count_leaf;
     }
 
@@ -149,10 +156,12 @@ export class BinaryUint32BVH {
 
     /**
      *
-     * @param {ArrayBuffer} v
+     * @param {ArrayBuffer} buffer
      */
-    set data(v) {
-        this.__data_buffer = v;
+    set data(buffer) {
+        assert.defined(buffer, 'buffer');
+
+        this.__data_buffer = buffer;
 
         this.__data_float32 = new Float32Array(this.__data_buffer);
         this.__data_uint32 = new Uint32Array(this.__data_buffer);
@@ -162,6 +171,24 @@ export class BinaryUint32BVH {
         return this.__data_buffer;
     }
 
+    /**
+     * Resolve index of the node to address where the node data starts, this is required to know where AABB is stored in memory
+     * @param {number} node_index
+     * @returns {number}
+     */
+    getNodeAddress(node_index) {
+        const binary_node_count = this.__node_count_binary;
+        const leaf_node_index = node_index - binary_node_count;
+
+        if (leaf_node_index < 0) {
+            // binary node
+            return node_index * BVH_BINARY_NODE_SIZE;
+        } else {
+            // leaf node
+            return binary_node_count * BVH_BINARY_NODE_SIZE + leaf_node_index * BVH_LEAF_NODE_SIZE;
+        }
+    }
+
     initialize_structure() {
         // compute memory requirements
         const word_count = this.__node_count_binary * BVH_BINARY_NODE_SIZE + this.__node_count_leaf * BVH_LEAF_NODE_SIZE;
@@ -452,22 +479,22 @@ export class BinaryUint32BVH {
 
         // build bottom-most level, just above the leaves
         for (i = 0; i < level_node_count; i++) {
-            const leafIndex0 = i * 2;
-            const leafIndex1 = leafIndex0 + 1;
+            const leaf_index_0 = i * 2;
+            const leaf_index_1 = leaf_index_0 + 1;
 
-            const leafOffset0 = leaf_node_block_address + leafIndex0 * BVH_LEAF_NODE_SIZE;
-            const leafOffset1 = leaf_node_block_address + leafIndex1 * BVH_LEAF_NODE_SIZE;
+            const leaf_offset_0 = leaf_node_block_address + leaf_index_0 * BVH_LEAF_NODE_SIZE;
+            const leaf_offset_1 = leaf_node_block_address + leaf_index_1 * BVH_LEAF_NODE_SIZE;
 
-            if (leafIndex1 < node_count_leaf) {
+            if (leaf_index_1 < node_count_leaf) {
                 // both children nodes are valid
                 aabb3_array_combine(
                     float32, offset,
-                    float32, leafOffset0,
-                    float32, leafOffset1
+                    float32, leaf_offset_0,
+                    float32, leaf_offset_1
                 );
-            } else if (leafIndex0 < node_count_leaf) {
+            } else if (leaf_index_0 < node_count_leaf) {
                 // only left child node is valid
-                array_copy(float32, leafOffset0, float32, offset, 6);
+                array_copy(float32, leaf_offset_0, float32, offset, 6);
             } else {
                 //initialize to 0-size box same position as previous node
                 copy_box_zero_size(this.__data_float32, offset, (offset - BVH_BINARY_NODE_SIZE));

package/src/core/bvh2/binary/2/BinaryUint32BVH.spec.js

@@ -19,7 +19,7 @@ test('0 leaf tree must have a no binary nodes', () => {
     bvh.initialize_structure();
     bvh.build();
 
-    expect(bvh.getBinaryNodeCount()).toBe(0);
+    expect(bvh.binary_node_count).toBe(0);
 });
 
 test('1 leaf tree must have a single binary node', () => {
@@ -29,7 +29,7 @@ test('1 leaf tree must have a single binary node', () => {
     bvh.initialize_structure();
     bvh.build();
 
-    expect(bvh.getBinaryNodeCount()).toBe(1);
+    expect(bvh.binary_node_count).toBe(1);
 });
 
 test('4 leaf tree must have a 3 binary nodes', () => {
@@ -39,7 +39,7 @@ test('4 leaf tree must have a 3 binary nodes', () => {
     bvh.initialize_structure();
     bvh.build();
 
-    expect(bvh.getBinaryNodeCount()).toBe(3);
+    expect(bvh.binary_node_count).toBe(3);
 });
 
 test('read/write 1 leaf', () => {

package/src/core/bvh2/binary/2/bvh32_query_user_data_overlaps_clipping_volume.js

@@ -0,0 +1,94 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import {
+    aabb3_array_intersects_clipping_volume_array
+} from "../../../geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
+ * @param {Float32Array|number[]} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @returns {number}
+ */
+export function bvh32_query_user_data_overlaps_clipping_volume(
+    result, result_offset,
+    bvh,
+    planes, planes_offset, plane_count
+) {
+    let hit_count = 0;
+
+    const binary_node_count = bvh.binary_node_count;
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[stack_top] = 0;
+
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
+
+    do {
+        stack.pointer--;
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stack.pointer];
+
+        const node_address = bvh.getNodeAddress(node_index);
+
+        if (!aabb3_array_intersects_clipping_volume_array(
+            float32, node_address,
+            planes, planes_offset, plane_count
+        )) {
+            continue;
+        }
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
+            // is intermediate node
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            // left node ends up on top of the stack, which aligns with the desired access sequence
+            if (right_index < last_valid_index) {
+                stack[stack.pointer++] = right_index;
+                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
+                stack[stack.pointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack[stack.pointer++] = left_index;
+            }
+
+
+        } else {
+            // leaf node
+
+            // write to output
+            result[result_offset + hit_count] = uint32[node_address + 6];
+
+            hit_count++;
+        }
+
+    } while (stack.pointer > stack_top)
+
+    return hit_count;
+}

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.js

@@ -1,14 +1,13 @@
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { aabb3_array_intersects_ray } from "../../../geom/3d/aabb/aabb3_array_intersects_ray.js";
-import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "./BinaryUint32BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
- * @param {BinaryUint32BVH} bvh
  * @param {number[]} result
  * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z
@@ -18,14 +17,14 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @returns {number}
  */
 export function bvh32_query_user_data_ray(
-    bvh,
     result, result_offset,
+    bvh,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z
 ) {
     let hit_count = 0;
 
-    const binary_node_count = bvh.getBinaryNodeCount();
+    const binary_node_count = bvh.binary_node_count;
 
     if (binary_node_count <= 0) {
         // this should not happen
@@ -44,7 +43,7 @@ export function bvh32_query_user_data_ray(
      */
     stack[stack_top] = 0;
 
-    const last_valid_index = binary_node_count + bvh.getLeafNodeCount();
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
 
     const float32 = bvh.float32;
     const uint32 = bvh.uint32;
@@ -55,17 +54,20 @@ export function bvh32_query_user_data_ray(
         // query_bvh_frustum_from_objects.iteration_count++;
         const node_index = stack[stack.pointer];
 
-        if (node_index < binary_node_count) {
+        const node_address = bvh.getNodeAddress(node_index);
+
+        if (!aabb3_array_intersects_ray(
+            float32, node_address,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        )) {
+            continue;
+        }
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
             // is intermediate node
-            const node_address = node_index * BVH_BINARY_NODE_SIZE;
-
-            if (!aabb3_array_intersects_ray(
-                float32, node_address,
-                origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z
-            )) {
-                continue;
-            }
 
             const left_index = (node_index << 1) + 1;
             const right_index = left_index + 1;
@@ -82,9 +84,6 @@ export function bvh32_query_user_data_ray(
 
         } else {
             // leaf node
-            const leaf_index = node_index - binary_node_count;
-
-            const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
 
             // write to output
             result[result_offset + hit_count] = uint32[node_address + 6];

package/src/core/bvh2/bvh3/query/BVHQueryIntersectsFrustum.js

@@ -1,4 +1,6 @@
-import { aabb3_array_intersects_frustum_array } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_array.js";
+import {
+    aabb3_array_intersects_clipping_volume_array
+} from "../../../geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js";
 import { BVHQuery } from "./BVHQuery.js";
 
 const scratch_aabb = [];
@@ -29,6 +31,6 @@ export class BVHQueryIntersectsFrustum extends BVHQuery {
 
         tree.node_get_aabb(node, scratch_aabb);
 
-        return aabb3_array_intersects_frustum_array(scratch_aabb, this.frustum);
+        return aabb3_array_intersects_clipping_volume_array(scratch_aabb, 0, this.frustum, 0, 6);
     }
 }

package/src/core/geom/3d/aabb/AABB3.js

@@ -3,20 +3,20 @@
  */
 
 
-import {assert} from "../../../assert.js";
+import { assert } from "../../../assert.js";
 import computeMortonCode from "../morton/Morton.js";
-import {aabb3_array_intersects_point} from "./aabb3_array_intersects_point.js";
-import {aabb3_build_corners} from "./aabb3_build_corners.js";
-import {aabb3_compute_distance_above_plane_max} from "./aabb3_compute_distance_above_plane_max.js";
-import {aabb3_compute_plane_side} from "./aabb3_compute_plane_side.js";
-import {aabb3_compute_surface_area} from "./aabb3_compute_surface_area.js";
-import {aabb3_intersects_frustum_array} from "./aabb3_intersects_frustum_array.js";
-import {aabb3_intersects_frustum_degree} from "./aabb3_intersects_frustum_degree.js";
-import {aabb3_intersects_line_segment} from "./aabb3_intersects_line_segment.js";
-import {aabb3_intersects_ray} from "./aabb3_intersects_ray.js";
-import {aabb3_matrix4_project} from "./aabb3_matrix4_project.js";
-import {aabb3_signed_distance_sqr_to_point} from "./aabb3_signed_distance_sqr_to_point.js";
-import {aabb3_signed_distance_to_aabb3} from "./aabb3_signed_distance_to_aabb3.js";
+import { aabb3_array_intersects_point } from "./aabb3_array_intersects_point.js";
+import { aabb3_build_corners } from "./aabb3_build_corners.js";
+import { aabb3_compute_distance_above_plane_max } from "./aabb3_compute_distance_above_plane_max.js";
+import { aabb3_compute_plane_side } from "./aabb3_compute_plane_side.js";
+import { aabb3_compute_surface_area } from "./aabb3_compute_surface_area.js";
+import { aabb3_intersects_clipping_volume_array } from "./aabb3_intersects_clipping_volume_array.js";
+import { aabb3_intersects_frustum_degree } from "./aabb3_intersects_frustum_degree.js";
+import { aabb3_intersects_line_segment } from "./aabb3_intersects_line_segment.js";
+import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
+import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+import { aabb3_signed_distance_sqr_to_point } from "./aabb3_signed_distance_sqr_to_point.js";
+import { aabb3_signed_distance_to_aabb3 } from "./aabb3_signed_distance_to_aabb3.js";
 
 /**
  * Axis-Aligned bounding box in 3D
@@ -850,7 +850,7 @@ export class AABB3 {
         const y1 = this.y1;
         const z1 = this.z1;
 
-        return aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum);
+        return aabb3_intersects_clipping_volume_array(x0, y0, z0, x1, y1, z1, frustum, 0, 6);
     }
 
     /**

package/src/core/geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js

@@ -0,0 +1,30 @@
+import { aabb3_intersects_clipping_volume_array } from "./aabb3_intersects_clipping_volume_array.js";
+
+/**
+ *
+ * @param {Float32Array|number[]} aabb
+ * @param {number} aabb_offset
+ * @param {Float32Array|number[]} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @return {boolean}
+ */
+export function aabb3_array_intersects_clipping_volume_array(
+    aabb, aabb_offset,
+    planes, planes_offset, plane_count
+) {
+
+    const x0 = aabb[aabb_offset + 0];
+    const y0 = aabb[aabb_offset + 1];
+    const z0 = aabb[aabb_offset + 2];
+    const x1 = aabb[aabb_offset + 3];
+    const y1 = aabb[aabb_offset + 4];
+    const z1 = aabb[aabb_offset + 5];
+
+    return aabb3_intersects_clipping_volume_array(
+        x0, y0, z0,
+        x1, y1, z1,
+        planes, planes_offset, plane_count
+    );
+}
+

package/src/core/geom/3d/aabb/aabb3_intersects_clipping_volume_array.js

@@ -0,0 +1,51 @@
+import { assert } from "../../../assert.js";
+import { aabb3_compute_distance_above_plane_max } from "./aabb3_compute_distance_above_plane_max.js";
+
+/**
+ * Tests whether AABB intersects a clipping volume defined by a set of planes
+ * Mainly useful for frustum checks
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @return {boolean}
+ */
+export function aabb3_intersects_clipping_volume_array(
+    x0, y0, z0,
+    x1, y1, z1,
+    planes, planes_offset, plane_count
+) {
+
+    assert.isNonNegativeInteger(planes_offset, 'frustum_offset');
+
+    const limit = plane_count * 4;
+
+    for (let i = 0; i < limit; i += 4) {
+
+        const offset = planes_offset + i;
+
+        const plane_x = planes[offset];
+        const plane_y = planes[offset + 1];
+        const plane_z = planes[offset + 2];
+        const plane_w = planes[offset + 3];
+
+        const plane_distance = aabb3_compute_distance_above_plane_max(
+            plane_x, plane_y, plane_z, plane_w,
+            x0, y0, z0,
+            x1, y1, z1
+        );
+
+        if (plane_distance < 0) {
+            return false;
+        }
+
+    }
+
+    return true;
+
+}

package/src/core/geom/3d/frustum/{read_frustum_planes_to_array.js → read_three_planes_to_array.js}

@@ -5,10 +5,12 @@ import { assert } from "../../../assert.js";
  * @param {Plane[]} planes
  * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} array
  */
-export function read_frustum_planes_to_array(planes, array) {
-    assert.greaterThanOrEqual(array.length, 24, 'target array is too small');
+export function read_three_planes_to_array(planes, array) {
+    const plane_count = planes.length;
 
-    for (let i = 0; i < 6; i++) {
+    assert.greaterThanOrEqual(array.length, plane_count * 4, 'target array is too small');
+
+    for (let i = 0; i < plane_count; i++) {
         const plane = planes[i];
 
         const offset = i * 4;

package/src/core/geom/3d/triangle/triangle_intersects_clipping_volume.js

@@ -0,0 +1,51 @@
+import { computeTrianglePlaneSide } from "./computeTrianglePlaneSide.js";
+
+/**
+ * @param {number[]|Float32Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function triangle_intersects_clipping_volume(
+    planes, planes_offset, plane_count,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+
+    for (let j = 0; j < plane_count; j++) {
+
+        const plane_address = planes_offset + j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        const side = computeTrianglePlaneSide(
+            plane_normal_x,
+            plane_normal_y,
+            plane_normal_z,
+            plane_constant,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        if (side === -3) {
+            // fully outside
+            return false;
+        }
+    }
+
+    return true;
+}

package/src/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -4,7 +4,7 @@ import {
     bvh_query_user_data_overlaps_frustum
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 import { noop } from "../../../../core/function/Functions.js";
-import { read_frustum_planes_to_array } from "../../../../core/geom/3d/frustum/read_frustum_planes_to_array.js";
+import { read_three_planes_to_array } from "../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
 import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { CameraSystem } from '../../../graphics/ecs/camera/CameraSystem.js';
@@ -255,7 +255,7 @@ class TerrainSystem extends System {
 
                 for (let i = 0; i < frustums.length; i++) {
 
-                    read_frustum_planes_to_array(frustums[i].planes, frustum);
+                    read_three_planes_to_array(frustums[i].planes, frustum);
 
                     found_tiles += bvh_query_user_data_overlaps_frustum(tiles, tile_count, tileManager.bvh, frustum);
                 }

package/src/engine/ecs/terrain/ecs/makeTerrainWorkerProxy.js

@@ -70,7 +70,7 @@ export function makeTerrainWorkerProxy() {
                     resolve({
                         geometry: geometry,
                         bvh: {
-                            leaf_count: bvh.getLeafNodeCount(),
+                            leaf_count: bvh.leaf_node_count,
                             data: bvh.data
                         }
                     });

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

@@ -13,7 +13,6 @@ import {
     Vector3 as ThreeVector3
 } from 'three';
 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";
@@ -21,11 +20,11 @@ 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 { bvh32_geometry_raycast } from "../../../graphics/geometry/buffered/query/bvh32_geometry_raycast.js";
 
 import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
 
@@ -33,9 +32,6 @@ 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 = [];
 
@@ -191,52 +187,19 @@ class TerrainTile {
         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;
 
         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);
-            }
-        }
+        let hit_found = bvh32_geometry_raycast(
+            result,
+            this.bvh,
+            geometryPositions, 0, 3,
+            geometryIndices,
+            _originX, _originY, _originZ,
+            _directionX, _directionY, _directionZ
+        );
 
         if (hit_found) {
             result.applyMatrix4(m4);