@woosh/meep-engine 2.163.10 → 2.164.0

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

@@ -0,0 +1,149 @@
+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 { aabb3_signed_distance_sqr_to_point } from "../../geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
+import { tri3_ray_intersection_indexed } from "../../geom/3d/triangle/tri3_ray_intersection_indexed.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, COLUMN_USER_DATA, ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+const v3_scratch_0 = [];
+
+/**
+ * Find ANY triangle intersected by the ray within the (min_distance, max_distance) range.
+ *
+ * Unlike {@link ebvh_geometry_query_nearest_triangle_ray}, this does not search for the
+ * closest hit — it returns as soon as a single qualifying intersection is found, which makes
+ * it suited to occlusion / shadow-ray style queries where only the presence of a hit matters.
+ *
+ * @param {number[]} output On a hit, receives [triangle_index, u, v, t]
+ * @param {number} output_offset
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number[]} ray `[origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]`.
+ *        The direction MUST be unit length: `t`, `min_distance` and `max_distance` are interpreted as
+ *        Euclidean distances from the origin, and the AABB distance-prune relies on that scale.
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @param {number[]|Uint32Array} indices
+ * @param {number[]|Float32Array} positions
+ * @returns {boolean} true if any triangle was hit
+ */
+export function ebvh_geometry_query_any_triangle_ray(
+    output, output_offset,
+    bvh, root,
+    ray, min_distance, max_distance,
+    indices, positions
+) {
+
+    if (root === NULL_NODE) {
+        // empty tree — no geometry to hit
+        return false;
+    }
+
+    const origin_x = ray[0];
+    const origin_y = ray[1];
+    const origin_z = ray[2];
+
+    const direction_x = ray[3];
+    const direction_y = ray[4];
+    const direction_z = ray[5];
+
+    // any AABB whose nearest point is beyond max_distance cannot contain a qualifying hit
+    const max_distance_sqr = max_distance * max_distance;
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        // test node against the ray
+        const aabb_x0 = float32[address];
+        const aabb_y0 = float32[address + 1];
+        const aabb_z0 = float32[address + 2];
+        const aabb_x1 = float32[address + 3];
+        const aabb_y1 = float32[address + 4];
+        const aabb_z1 = float32[address + 5];
+
+        const intersects = aabb3_intersects_ray(
+            aabb_x0, aabb_y0, aabb_z0,
+            aabb_x1, aabb_y1, aabb_z1,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        );
+
+        if (!intersects) {
+            continue;
+        }
+
+        const distance = aabb3_signed_distance_sqr_to_point(
+            aabb_x0, aabb_y0, aabb_z0,
+            aabb_x1, aabb_y1, aabb_z1,
+            origin_x, origin_y, origin_z
+        );
+
+        if (distance > max_distance_sqr) {
+            // whole AABB is too far
+            continue;
+        }
+
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+
+            // this is not a leaf node, push children onto traversal stack
+            stack[stack.pointer++] = child_1;
+            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
+            continue;
+        }
+
+        // leaf node
+        const triangle_index = uint32[address + COLUMN_USER_DATA];
+
+        const intersection_found = tri3_ray_intersection_indexed(
+            v3_scratch_0,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z,
+            indices, triangle_index,
+            positions
+        );
+
+        if (intersection_found && v3_scratch_0[0] < max_distance && v3_scratch_0[0] > min_distance) {
+            // found a qualifying hit, report it immediately and stop traversal
+
+            // unwind the traversal stack down to the entry point
+            stack.pointer = stack_top;
+
+            output[output_offset] = triangle_index; // index of hit triangle
+            output[output_offset + 1] = v3_scratch_0[1];
+            output[output_offset + 2] = v3_scratch_0[2];
+            output[output_offset + 3] = v3_scratch_0[0];
+
+            return true;
+        }
+
+    } while (stack.pointer > stack_top);
+
+    // no intersection
+    return false;
+}

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

@@ -1,14 +1,17 @@
 /**
  *
- * @param {number[]} output
+ * @param {number[]} output On a hit, receives [triangle_index, u, v, t]
  * @param {number} output_offset
  * @param {BVH} bvh
  * @param {number} root
- * @param {number[]} ray
+ * @param {number[]} ray `[origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]`.
+ *        The direction MUST be unit length: `t`, `min_distance` and `max_distance` are interpreted as
+ *        Euclidean distances from the origin, and the AABB distance-prune relies on that scale.
  * @param {number} min_distance
  * @param {number} max_distance
  * @param {number[]|Uint32Array} indices
  * @param {number[]|Float32Array} positions
+ * @returns {boolean} true if a triangle was hit
  */
 export function ebvh_geometry_query_nearest_triangle_ray(output: number[], output_offset: number, bvh: BVH, root: number, ray: number[], min_distance: number, max_distance: number, indices: number[] | Uint32Array, positions: number[] | Float32Array): boolean;
 //# sourceMappingURL=ebvh_geometry_query_nearest_triangle_ray.d.ts.map

package/src/core/bvh2/bvh3/ebvh_geometry_query_nearest_triangle_ray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_geometry_query_nearest_triangle_ray.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_geometry_query_nearest_triangle_ray.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;GAWG;AACH,iEAVW,MAAM,EAAE,iBACR,MAAM,kBAEN,MAAM,OACN,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,WACN,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,EAAE,GAAC,YAAY,WA4H/B"}
+{"version":3,"file":"ebvh_geometry_query_nearest_triangle_ray.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_geometry_query_nearest_triangle_ray.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,EAAE,iBACR,MAAM,kBAEN,MAAM,OACN,MAAM,EAAE,gBAGR,MAAM,gBACN,MAAM,WACN,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAiInB"}

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

@@ -1,9 +1,7 @@
 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 { aabb3_signed_distance_sqr_to_point } from "../../geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
-import {
-    computeTriangleRayIntersectionBarycentricGeometry
-} from "../../geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js";
+import { tri3_ray_intersection_indexed } from "../../geom/3d/triangle/tri3_ray_intersection_indexed.js";
 import { COLUMN_CHILD_1, COLUMN_CHILD_2, COLUMN_USER_DATA, ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
@@ -11,15 +9,18 @@ const v3_scratch_0 = [];
 
 /**
  *
- * @param {number[]} output
+ * @param {number[]} output On a hit, receives [triangle_index, u, v, t]
  * @param {number} output_offset
  * @param {BVH} bvh
  * @param {number} root
- * @param {number[]} ray
+ * @param {number[]} ray `[origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]`.
+ *        The direction MUST be unit length: `t`, `min_distance` and `max_distance` are interpreted as
+ *        Euclidean distances from the origin, and the AABB distance-prune relies on that scale.
  * @param {number} min_distance
  * @param {number} max_distance
  * @param {number[]|Uint32Array} indices
  * @param {number[]|Float32Array} positions
+ * @returns {boolean} true if a triangle was hit
  */
 export function ebvh_geometry_query_nearest_triangle_ray(
     output, output_offset,
@@ -28,6 +29,11 @@ export function ebvh_geometry_query_nearest_triangle_ray(
     indices, positions
 ) {
 
+    if (root === NULL_NODE) {
+        // empty tree — no geometry to hit
+        return false;
+    }
+
     const origin_x = ray[0];
     const origin_y = ray[1];
     const origin_z = ray[2];
@@ -112,7 +118,7 @@ export function ebvh_geometry_query_nearest_triangle_ray(
         // leaf node
         const triangle_index = uint32[address + COLUMN_USER_DATA];
 
-        const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
+        const intersection_found = tri3_ray_intersection_indexed(
             v3_scratch_0,
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_z,
@@ -137,10 +143,10 @@ export function ebvh_geometry_query_nearest_triangle_ray(
         return false;
     }
 
-    output[0] = best_index; // index of hit triangle
-    output[1] = best_u;
-    output[2] = best_v;
-    output[3] = best_t;
+    output[output_offset] = best_index; // index of hit triangle
+    output[output_offset + 1] = best_u;
+    output[output_offset + 2] = best_v;
+    output[output_offset + 3] = best_t;
 
     return true;
 }

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QAgJhB"}
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QA6JhB"}

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

@@ -318,12 +318,25 @@ export function ebvh_optimize_treelet(
     while (true) {
 
 
-        if (
-            came_from_type === CAME_FROM_TYPE_CHILD_2
-            && bvh.node_get_height(node) >= min_height
-        ) {
-            // only form treelets when moving up
-            optimize_at_node(bvh, node, treelet_size);
+        if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
+            // We are moving up into `node` having fully processed both of its
+            // subtrees (including any treelets optimized within them, which can
+            // change a child's height). Refresh `node`'s height from its children
+            // before using it: this keeps the min_height gate below honest and
+            // propagates corrected heights all the way to the root as the walk
+            // ascends, so later height consumers don't read stale values.
+            const child_1 = bvh.node_get_child1(node);
+            const child_2 = bvh.node_get_child2(node);
+
+            bvh.node_set_height(
+                node,
+                1 + Math.max(bvh.node_get_height(child_1), bvh.node_get_height(child_2))
+            );
+
+            if (bvh.node_get_height(node) >= min_height) {
+                // only form treelets when moving up
+                optimize_at_node(bvh, node, treelet_size);
+            }
         }
 
         // only add to treelet when traversing up, not down

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

@@ -1,7 +1,18 @@
 /**
- * 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
+ * Relocate live nodes so that their memory slots follow depth-first pre-order
+ * (parent first, then child1's subtree, then child2's subtree). This is exactly
+ * the order the query traversals visit nodes in (they push child2 then child1,
+ * so child1 is popped first), so a full top-down traversal then walks the
+ * backing buffer close to linearly — near-optimal cache usage.
+ *
+ * The layout is produced by computing each node's target slot from a single DFS
+ * and rewriting every record into its new slot with links remapped. This is a
+ * pure function of the tree shape, so the result is deterministic.
+ *
+ * NOTE: assumes the tree is compacted — there are no free/unreachable nodes, so
+ * slots [0, size) are exactly the nodes reachable from the root. Call after a
+ * static build, or after a compaction pass.
+ *
  * @param {BVH} bvh
  */
 export function ebvh_sort_for_traversal_depth_first(bvh: BVH): void;

package/src/core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_sort_for_traversal_depth_first.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oEAwDC"}
+{"version":3,"file":"ebvh_sort_for_traversal_depth_first.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,oEA2EC"}

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

@@ -1,116 +1,96 @@
-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 {BVH} bvh
- */
-export function ebvh_sort_for_traversal_depth_first(bvh) {
-    const stack = [];
-
-    stack[0] = 0;
-    stack[1] = bvh.__size - 1;
-
-    let stack_pointer = 2;
-    let i, j;
-
-    const uint32 = bvh.__data_uint32;
-    const float32 = bvh.__data_float32;
-
-    while (stack_pointer > 0) {
-        stack_pointer -= 2;
-
-        const right = stack[stack_pointer + 1];
-        const left = stack[stack_pointer];
-
-        i = left;
-        j = right;
-
-        const pivotIndex = (left + right) >> 1;
-
-        /* partition */
-        while (i <= j) {
-
-            while (traversal_sort_compare_nodes(uint32, float32, i, pivotIndex) > 0) {
-                i++;
-            }
-
-            while (traversal_sort_compare_nodes(uint32, float32, j, pivotIndex) < 0) {
-                j--;
-            }
-
-            if (i <= j) {
-
-                if (i !== j) {
-                    //do swap
-                    bvh.swap_nodes(i, j);
-                }
-
-                i++;
-                j--;
-            }
-        }
-
-        /* recursion */
-        if (left < j) {
-            stack[stack_pointer++] = left;
-            stack[stack_pointer++] = j;
-        }
-        if (i < right) {
-            stack[stack_pointer++] = i;
-            stack[stack_pointer++] = right;
-        }
-    }
-}
-
-/**
- *
- * @param {Uint32Array} uint32
- * @param {number} node_index
- * @return {number}
- */
-function compute_traversal_index_upper_bound(uint32, node_index) {
-    let n = node_index;
-
-    let parent = uint32[node_index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
-
-    let result = 0;
-    let x = 0;
-
-    while (parent !== NULL_NODE) {
-
-        if (uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === n) {
-            result += Math.pow(2, x);
-        }
-
-        x++;
-
-        n = parent;
-        parent = uint32[n * ELEMENT_WORD_COUNT + COLUMN_PARENT];
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {Uint32Array} uint32
- * @param {Float32Array} float32
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-function traversal_sort_compare_nodes(uint32, float32, a, b) {
-    const a_height = uint32[a * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
-    const b_height = uint32[b * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
-
-    const height_delta = a_height - b_height;
-
-    if (height_delta !== 0) {
-        return height_delta;
-    }
-
-    return compute_traversal_index_upper_bound(uint32, a) - compute_traversal_index_upper_bound(uint32, b);
-
-}
+import { assert } from "../../assert.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, COLUMN_PARENT, ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
+
+/**
+ * Relocate live nodes so that their memory slots follow depth-first pre-order
+ * (parent first, then child1's subtree, then child2's subtree). This is exactly
+ * the order the query traversals visit nodes in (they push child2 then child1,
+ * so child1 is popped first), so a full top-down traversal then walks the
+ * backing buffer close to linearly — near-optimal cache usage.
+ *
+ * The layout is produced by computing each node's target slot from a single DFS
+ * and rewriting every record into its new slot with links remapped. This is a
+ * pure function of the tree shape, so the result is deterministic.
+ *
+ * NOTE: assumes the tree is compacted — there are no free/unreachable nodes, so
+ * slots [0, size) are exactly the nodes reachable from the root. Call after a
+ * static build, or after a compaction pass.
+ *
+ * @param {BVH} bvh
+ */
+export function ebvh_sort_for_traversal_depth_first(bvh) {
+    const size = bvh.size;
+
+    if (size <= 1) {
+        // nothing to reorder
+        return;
+    }
+
+    const root = bvh.root;
+
+    const uint32 = bvh.__data_uint32;
+
+    // 1. DFS pre-order from the root: assign each node its target slot.
+    //    new_slot[old_node_id] = destination slot index.
+    const new_slot = new Uint32Array(size);
+
+    const stack = [];
+    let stack_pointer = 0;
+    let cursor = 0;
+
+    if (root !== NULL_NODE) {
+        stack[stack_pointer++] = root;
+    }
+
+    while (stack_pointer > 0) {
+        const node = stack[--stack_pointer];
+
+        new_slot[node] = cursor++;
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+            const child_2 = uint32[address + COLUMN_CHILD_2];
+
+            // push child2 first so child1 is popped (and laid out) first
+            stack[stack_pointer++] = child_2;
+            stack[stack_pointer++] = child_1;
+        }
+    }
+
+    // every live slot must have been reached exactly once; if not, the tree had
+    // free/unreachable nodes, which violates the precondition.
+    assert.equal(cursor, size, 'sort requires a compacted tree (no free/unreachable nodes)');
+
+    // 2. Snapshot the current records (a general permutation can overwrite a
+    //    source slot before it is read, so we cannot move in place).
+    const old = uint32.slice(0, size * ELEMENT_WORD_COUNT);
+
+    // 3. Write each node into its new slot, remapping parent/child references.
+    for (let old_id = 0; old_id < size; old_id++) {
+        const source = old_id * ELEMENT_WORD_COUNT;
+        const destination = new_slot[old_id] * ELEMENT_WORD_COUNT;
+
+        // AABB (words 0..5) and HEIGHT copy verbatim
+        for (let w = 0; w < ELEMENT_WORD_COUNT; w++) {
+            uint32[destination + w] = old[source + w];
+        }
+
+        const parent = old[source + COLUMN_PARENT];
+        uint32[destination + COLUMN_PARENT] = parent === NULL_NODE ? NULL_NODE : new_slot[parent];
+
+        const child_1 = old[source + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+            // internal node: remap both children
+            uint32[destination + COLUMN_CHILD_1] = new_slot[child_1];
+            uint32[destination + COLUMN_CHILD_2] = new_slot[old[source + COLUMN_CHILD_2]];
+        }
+        // leaf: CHILD_1 stays NULL_NODE and CHILD_2/USER_DATA was copied verbatim above
+    }
+
+    // 4. The root moved with everything else.
+    bvh.root = new_slot[root];
+}

package/src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.d.ts

@@ -1,9 +1,9 @@
 /**
  * Traverses bvh starting from a given node, but can back-track all the way up to the root
+ * @param {number[]|Uint32Array} result
+ * @param {number} result_offset
  * @param {BVH} bvh
  * @param {number} starting_node
- * @param {number[]} result
- * @param {number} result_offset
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z
@@ -12,5 +12,5 @@
  * @param {number} direction_z
  * @returns {number}
  */
-export function bvh_backtracking_query_leaves_ray(bvh: BVH, starting_node: number, result: number[], result_offset: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): number;
+export function bvh_backtracking_query_leaves_ray(result: number[] | Uint32Array, result_offset: number, bvh: BVH, starting_node: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): number;
 //# sourceMappingURL=bvh_backtracking_query_leaves_ray.d.ts.map

package/src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh_backtracking_query_leaves_ray.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,2EAXW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,MAAM,CA6GlB"}
+{"version":3,"file":"bvh_backtracking_query_leaves_ray.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,0DAZW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,2BAEN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,MAAM,CA6GlB"}

package/src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.js

@@ -8,10 +8,10 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  * Traverses bvh starting from a given node, but can back-track all the way up to the root
+ * @param {number[]|Uint32Array} result
+ * @param {number} result_offset
  * @param {BVH} bvh
  * @param {number} starting_node
- * @param {number[]} result
- * @param {number} result_offset
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z
@@ -21,8 +21,8 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @returns {number}
  */
 export function bvh_backtracking_query_leaves_ray(
-    bvh, starting_node,
     result, result_offset,
+    bvh, starting_node,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z
 ) {

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

@@ -1,5 +1,5 @@
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_array_intersects_frustum_degree } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_degree.js";
+import { aabb3_classify_against_frustum_array } from "../../../geom/3d/aabb/aabb3_classify_against_frustum_array.js";
 import { aabb3_compute_distance_above_plane_max } from "../../../geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
 import { aabb3_compute_distance_above_plane_min } from "../../../geom/3d/aabb/aabb3_compute_distance_above_plane_min.js";
 import { NULL_NODE } from "../BVH.js";
@@ -64,7 +64,7 @@ export function bvh_query_depth_range_in_frustum(
         const y1 = scratch_aabb[4];
         const z1 = scratch_aabb[5];
 
-        const intersection = aabb3_array_intersects_frustum_degree(scratch_aabb, 0, frustum);
+        const intersection = aabb3_classify_against_frustum_array(scratch_aabb, 0, frustum);
 
         if (intersection === 0) {
             continue;

package/src/core/bvh2/bvh3/query/bvh_query_leaves_generic.d.ts

@@ -1,11 +1,18 @@
 /**
+ * Collect every leaf node accepted by `query`, walking the tree from `root`.
  *
+ * Uses the shared {@link SCRATCH_UINT32_TRAVERSAL_STACK}: `query.evaluate` MUST NOT throw and
+ * MUST NOT start another traversal that consumes the same stack. On a throw the shared stack
+ * pointer is left elevated, silently corrupting every subsequent traversal. We deliberately do
+ * NOT wrap the loop in try/finally — that forces a V8 de-opt on this hot path; not throwing from
+ * the predicate is a precondition, not something to defend against at runtime.
+ *
+ * @param {number[]|Uint32Array} result destination for matched leaf node ids
+ * @param {number} result_offset first index in `result` to write to
  * @param {BVH} bvh
- * @param {number[]} result
- * @param {number} result_offset
  * @param {number} root
- * @param {BVHQuery} query
- * @returns {number}
+ * @param {BVHQuery} query per-node predicate; must be conservative at internal nodes
+ * @returns {number} number of entries written
  */
-export function bvh_query_leaves_generic(result: number[], result_offset: number, bvh: BVH, root: number, query: BVHQuery): number;
+export function bvh_query_leaves_generic(result: number[] | Uint32Array, result_offset: number, bvh: BVH, root: number, query: BVHQuery): number;
 //# sourceMappingURL=bvh_query_leaves_generic.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_leaves_generic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh_query_leaves_generic.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_leaves_generic.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,iDANW,MAAM,EAAE,iBACR,MAAM,kBACN,MAAM,oBAEJ,MAAM,CAyDlB"}
+{"version":3,"file":"bvh_query_leaves_generic.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_leaves_generic.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,iDAPW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,kBAEN,MAAM,oBAEJ,MAAM,CAyDlB"}

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

@@ -4,13 +4,20 @@ import { NULL_NODE } from "../BVH.js";
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
+ * Collect every leaf node accepted by `query`, walking the tree from `root`.
  *
+ * Uses the shared {@link SCRATCH_UINT32_TRAVERSAL_STACK}: `query.evaluate` MUST NOT throw and
+ * MUST NOT start another traversal that consumes the same stack. On a throw the shared stack
+ * pointer is left elevated, silently corrupting every subsequent traversal. We deliberately do
+ * NOT wrap the loop in try/finally — that forces a V8 de-opt on this hot path; not throwing from
+ * the predicate is a precondition, not something to defend against at runtime.
+ *
+ * @param {number[]|Uint32Array} result destination for matched leaf node ids
+ * @param {number} result_offset first index in `result` to write to
  * @param {BVH} bvh
- * @param {number[]} result
- * @param {number} result_offset
  * @param {number} root
- * @param {BVHQuery} query
- * @returns {number}
+ * @param {BVHQuery} query per-node predicate; must be conservative at internal nodes
+ * @returns {number} number of entries written
  */
 export function bvh_query_leaves_generic(
     result, result_offset,