@woosh/meep-engine 2.64.0 → 2.66.0

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

@@ -63,6 +63,60 @@ test('read/write 1 leaf', () => {
     expect(bounds[5]).toBeCloseTo(23);
 });
 
+test("2 leaf node build", () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(2);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
+    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
+
+    bvh.build();
+
+    const bounds = [];
+
+    bvh.readBounds(0, bounds, 0);
+
+    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 1.4, 1.5, 1.6])));
+});
+
+test("1 leaf node build", () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(1);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
+
+    bvh.build();
+
+    const bounds = [];
+
+    bvh.readBounds(0, bounds, 0);
+
+    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])));
+});
+
+test("3 leaf node build", () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(3);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
+    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
+    bvh.setLeafData(2, 11, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6);
+
+    bvh.build();
+
+    const bounds = [];
+
+    bvh.readBounds(0, bounds, 0);
+
+    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 2.4, 2.5, 2.6])));
+});
+
 test('4 node sorted build', () => {
     const bvh = new BinaryUint32BVH();
 

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

@@ -0,0 +1,98 @@
+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 {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {number}
+ */
+export function bvh32_query_user_data_ray(
+    bvh,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    let hit_count = 0;
+
+    const binary_node_count = bvh.getBinaryNodeCount();
+
+    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.getLeafNodeCount();
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
+
+    do {
+        stack.pointer--;
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stack.pointer];
+
+        if (node_index < binary_node_count) {
+            // 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;
+
+            // 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
+            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];
+
+            hit_count++;
+        }
+
+    } while (stack.pointer > stack_top)
+
+    return hit_count;
+}

package/src/core/bvh2/bvh3/{ExplicitBinaryBoundingVolumeHierarchy.d.ts → BVH.d.ts}

@@ -1,4 +1,4 @@
-export class ExplicitBinaryBoundingVolumeHierarchy {
+export declare class BVH {
     readonly root: number
 
     node_capacity: number

package/src/core/bvh2/bvh3/{ExplicitBinaryBoundingVolumeHierarchy.js → BVH.js}

@@ -58,7 +58,7 @@ const INITIAL_CAPACITY = 128;
  * @see https://blog.dashlane.com/how-is-data-stored-in-v8-js-engine-memory
  * @class
  */
-export class ExplicitBinaryBoundingVolumeHierarchy {
+export class BVH {
 
     /**
      *
@@ -993,7 +993,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
     /**
      *
-     * @param {function(node:number, tree:ExplicitBinaryBoundingVolumeHierarchy):void} callback
+     * @param {function(node:number, tree:BVH):void} callback
      * @param {*} [ctx]
      */
     traverse(callback, ctx) {

package/src/core/bvh2/bvh3/{ExplicitBinaryBoundingVolumeHierarchy.spec.js → BVH.spec.js}

@@ -1,17 +1,17 @@
-import { ExplicitBinaryBoundingVolumeHierarchy, NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { BVH, NULL_NODE } from "./BVH.js";
 
 test("constructor doesn't throw", () => {
-    expect(() => new ExplicitBinaryBoundingVolumeHierarchy()).not.toThrow();
+    expect(() => new BVH()).not.toThrow();
 });
 
 test("initial root is NULL", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     expect(bvh.root).toBe(NULL_NODE);
 });
 
 test("allocate a node", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const id = bvh.allocate_node();
 
@@ -21,7 +21,7 @@ test("allocate a node", () => {
 });
 
 test("set/get aabb", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const node = bvh.allocate_node();
 
@@ -37,7 +37,7 @@ test("set/get aabb", () => {
 });
 
 test("insert one leaf", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const node = bvh.allocate_node();
 
@@ -48,7 +48,7 @@ test("insert one leaf", () => {
 
 test("node reuse after de-allocation", () => {
 
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const a = bvh.allocate_node();
 
@@ -61,7 +61,7 @@ test("node reuse after de-allocation", () => {
 
 test("insert two leaves", () => {
 
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const a = bvh.allocate_node();
     bvh.insert_leaf(a);
@@ -79,7 +79,7 @@ test("insert two leaves", () => {
 
 test("set/get user data", () => {
 
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const a = bvh.allocate_node();
 
@@ -89,7 +89,7 @@ test("set/get user data", () => {
 });
 
 test("remove single leaf", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const a = bvh.allocate_node();
     bvh.insert_leaf(a);
@@ -104,7 +104,7 @@ test("remove single leaf", () => {
 
 test("add and remove 5 nodes", () => {
 
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const leaves = [];
     const removed_leaves = [];
@@ -146,13 +146,13 @@ test("add and remove 5 nodes", () => {
 
 
 test("release_all from empty doesn't throw", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     expect(() => bvh.release_all()).not.toThrow();
 });
 
 test("release_all with 1 leaf", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const a = bvh.allocate_node();
 
@@ -164,7 +164,7 @@ test("release_all with 1 leaf", () => {
 });
 
 test("capacity grows as necessary when allocating", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     bvh.node_capacity = 1;
 
@@ -176,7 +176,7 @@ test("capacity grows as necessary when allocating", () => {
 });
 
 test("trim sets capacity to exact allocated size", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     bvh.node_capacity = 1;
 
@@ -192,7 +192,7 @@ test("trim sets capacity to exact allocated size", () => {
 
 test("node property setters/getters", () => {
 
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const node = bvh.allocate_node();
 
@@ -221,7 +221,7 @@ test("node property setters/getters", () => {
 
 
 test("node_set_aabb_primitive", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const node = bvh.allocate_node();
 
@@ -235,7 +235,7 @@ test("node_set_aabb_primitive", () => {
 });
 
 test("swap two detached nodes", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const a = bvh.allocate_node();
     const b = bvh.allocate_node();
@@ -250,7 +250,7 @@ test("swap two detached nodes", () => {
 });
 
 test("setting capacity", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     bvh.node_capacity = 3;
 
@@ -278,7 +278,7 @@ test("setting capacity", () => {
 });
 
 test("move leaf node", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const a = bvh.allocate_node();
     const b = bvh.allocate_node();

package/src/core/bvh2/bvh3/BvhClient.d.ts

@@ -0,0 +1,11 @@
+import {BVH} from "./BVH";
+
+export declare class BvhClient{
+    readonly is_linked:boolean
+    readonly bounds:ArrayLike<number>
+
+    write_bound():void
+
+    link(tree:BVH,data:number):void
+    unlink():void
+}

package/src/core/bvh2/bvh3/{EBBVHLeafProxy.js → BvhClient.js}

@@ -1,12 +1,13 @@
 import { assert } from "../../assert.js";
+import { aabb3_array_set } from "../../geom/3d/aabb/aabb3_array_set.js";
 
 /**
  * A convenience class to work with BVH leaf nodes
  */
-export class EBBVHLeafProxy {
+export class BvhClient {
     /**
      *
-     * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
+     * @type {BVH|null}
      */
     #tree = null;
 
@@ -28,7 +29,7 @@ export class EBBVHLeafProxy {
 
     /**
      *
-     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
+     * @param {BVH} tree
      * @param {number} data Must be a uint32
      */
     link(tree, data) {
@@ -67,4 +68,22 @@ export class EBBVHLeafProxy {
 
         this.#tree.node_move_aabb(this.#node_id, this.bounds);
     }
+
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     */
+    resize(x0, y0, z0, x1, y1, z1) {
+        aabb3_array_set(
+            this.bounds, 0,
+            x0, y0, z0, x1, y1, z1
+        );
+
+        this.write_bounds();
+    }
 }

package/src/core/bvh2/bvh3/BvhClient.spec.js

@@ -0,0 +1,51 @@
+import { BVH } from "./BVH.js";
+import { BvhClient } from "./BvhClient.js";
+import { bvh_query_leaves_generic } from "./query/bvh_query_leaves_generic.js";
+import { BVHQueryAny } from "./query/BVHQueryAny.js";
+
+test("connect/disconnect", () => {
+
+    const client = new BvhClient();
+
+    const bvh = new BVH();
+
+    client.bounds[0] = 2
+    client.bounds[1] = 3
+    client.bounds[2] = 5
+    client.bounds[3] = 7
+    client.bounds[4] = 11
+    client.bounds[5] = 13
+
+    expect(client.is_linked).toBe(false);
+
+    client.link(bvh, 17);
+
+    expect(client.is_linked).toBe(true);
+
+    const leaves = [];
+    bvh_query_leaves_generic(leaves, 0, bvh, bvh.root, BVHQueryAny.INSTANCE);
+
+    expect(leaves.length).toEqual(1);
+
+    const leaf = leaves[0];
+
+    expect(bvh.node_get_user_data(leaf)).toEqual(17);
+
+    const aabb = [];
+
+    bvh.node_get_aabb(leaf, aabb);
+
+    expect(aabb).toEqual(Array.from(client.bounds));
+
+    // disconnect
+    client.unlink();
+
+    expect(client.is_linked).toBe(false);
+
+    expect(bvh_query_leaves_generic(
+        leaves, 0,
+        bvh, bvh.root,
+        BVHQueryAny.INSTANCE
+    ))
+        .toBe(0);
+});

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js

@@ -1,9 +1,9 @@
-import { min2 } from "../../math/min2.js";
 import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
+import { min2 } from "../../math/min2.js";
 
 /**
  * Build the BVH by relying on BVH's own incremental insertion mechanism
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  * @param {number[]|Float32Array} index_array
  * @param {number[]|Float32Array} positions_array
  * @param {number} [batch_size] can batch triangles in groups of up-to this many triangles per BVH leaf

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -1,15 +1,15 @@
+import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
+import { arrayQuickSort } from "../../collection/array/arrayQuickSort.js";
 import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
 import morton from "../../geom/3d/morton/Morton.js";
-import { arrayQuickSort } from "../../collection/array/arrayQuickSort.js";
-import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
 import { max2 } from "../../math/max2.js";
+import { NULL_NODE } from "./BVH.js";
 
 /**
  * Build the BVH bottom-up using spatial hash sorting
  * Resulting BVH is produced very quickly, has perfect balance and is of decent quality
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  * @param {number[]|Float32Array} index_array
  * @param {number[]|Float32Array} position_array
  */

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.spec.js

@@ -1,9 +1,9 @@
+import { BVH, NULL_NODE } from "./BVH.js";
 import { ebvh_build_for_geometry_morton } from "./ebvh_build_for_geometry_morton.js";
-import { ExplicitBinaryBoundingVolumeHierarchy, NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
 
 test("sanity check with 1 triangle", () => {
 
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     ebvh_build_for_geometry_morton(bvh, [0, 1, 2], [
         0, 1, 3,
@@ -29,7 +29,7 @@ test("sanity check with 1 triangle", () => {
 });
 
 test("sanity check with 2 triangles", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     ebvh_build_for_geometry_morton(
         bvh,

package/src/core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js

@@ -1,16 +1,10 @@
-import {
-    COLUMN_CHILD_1,
-    COLUMN_HEIGHT,
-    COLUMN_PARENT,
-    ELEMENT_WORD_COUNT,
-    NULL_NODE
-} from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { COLUMN_CHILD_1, COLUMN_HEIGHT, COLUMN_PARENT, ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 
 /**
  * Sort live nodes in the traversal order.
  * This makes most queries have linear access, resulting in near-optimal cache usage
  * NOTE: assumes that there are no free nodes
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  */
 export function ebvh_sort_for_traversal_depth_first(bvh) {
     const stack = [];

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

@@ -2,7 +2,7 @@ export class BVHQuery {
     /**
      *
      * @param {number} node
-     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
+     * @param {BVH} tree
      * @returns {boolean}
      */
     evaluate(node, tree) {

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

@@ -1,7 +1,7 @@
 //
 
-import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { NULL_NODE } from "../BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
@@ -9,7 +9,7 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  *
  * @param {number[]} destination
  * @param {number} destination_offset
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  * @param {number} root
  * @returns {number} number of collected elements
  */

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

@@ -1,11 +1,11 @@
-import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { NULL_NODE } from "../BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  * @param {number[]} result
  * @param {number} result_offset
  * @param {number} root

package/src/core/bvh2/bvh3/query/bvh_query_leaves_generic.spec.js

@@ -1,9 +1,9 @@
-import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { BVH } from "../BVH.js";
 import { bvh_query_leaves_generic } from "./bvh_query_leaves_generic.js";
 import { BVHQueryAny } from "./BVHQueryAny.js";
 
 test("all-accepting query", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const leaf_a = bvh.allocate_node();
     const leaf_b = bvh.allocate_node();

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

@@ -1,18 +1,13 @@
-import { aabb3_intersects_ray } from "../../../geom/3d/aabb/aabb3_intersects_ray.js";
-import {
-    COLUMN_CHILD_1,
-    COLUMN_CHILD_2,
-    ELEMENT_WORD_COUNT,
-    NULL_NODE
-} from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_intersects_ray } from "../../../geom/3d/aabb/aabb3_intersects_ray.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 
 /**
  *
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  * @param {number} root
  * @param {number[]} result
  * @param {number} result_offset

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray.spec.js

@@ -1,4 +1,4 @@
-import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { BVH } from "../BVH.js";
 import { bvh_query_leaves_ray } from "./bvh_query_leaves_ray.js";
 
 /**
@@ -7,7 +7,7 @@ import { bvh_query_leaves_ray } from "./bvh_query_leaves_ray.js";
  */
 function makeBVH(...leaves) {
 
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     for (let i = 0; i < leaves.length; i++) {
 

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

@@ -1,13 +1,13 @@
 import { assert } from "../../../assert.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { NULL_NODE } from "../BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 
 /**
  *
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  * @param {number[]} result
  * @param {number} result_offset
  * @param {number} root

package/src/core/bvh2/bvh3/query/bvh_query_user_data_generic.spec.js

@@ -1,9 +1,9 @@
-import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { BVH } from "../BVH.js";
 import { bvh_query_user_data_generic } from "./bvh_query_user_data_generic.js";
 import { BVHQueryAny } from "./BVHQueryAny.js";
 
 test("all-accepting query", () => {
-    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+    const bvh = new BVH();
 
     const leaf_a = bvh.allocate_node();
     const leaf_b = bvh.allocate_node();

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

@@ -1,7 +1,7 @@
-import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { aabb3_signed_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
 import { max2 } from "../../../math/max2.js";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { NULL_NODE } from "../BVH.js";
 
 /**
  *
@@ -13,7 +13,7 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
- * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {BVH} bvh
  * @param {number} x
  * @param {number} y
  * @param {number} z