@woosh/meep-engine 2.169.0 → 2.169.2

package/src/core/geom/2d/line/segment2_intersects_segment2_2d.js

@@ -1,29 +1,25 @@
-/**
- *
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @returns {boolean} True if segments intersect, False otherwise
- * @public
- */
-export function segment2_intersects_segment2_2d(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-    const dy_02 = a0_y - b0_y;
-    const dx_02 = a0_x - b0_x;
-
-    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
-
-    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
-    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
-
-    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
-}
+import { segment2_segment_intersection_fractions } from "./segment2_segment_intersection_fractions.js";
+
+// the fractions themselves are discarded by this boolean face
+const scratch_fractions = new Float64Array(2);
+
+/**
+ *
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} True if segments intersect, False otherwise
+ * @public
+ */
+export function segment2_intersects_segment2_2d(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
+    return segment2_segment_intersection_fractions(
+        scratch_fractions, 0,
+        a0_x, a0_y, a1_x, a1_y,
+        b0_x, b0_y, b1_x, b1_y
+    );
+}

package/src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment2_segment_compute_intersection_array_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,uEAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACL,OAAO,CAkClB"}
+{"version":3,"file":"segment2_segment_compute_intersection_array_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,uEAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACL,OAAO,CAyBlB"}

package/src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.js

@@ -1,51 +1,46 @@
-/**
- *
- * Find intersection point between two line segments if they intersect at all
- * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
- * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
- *
- * @param {number[]|Float32Array|Float64Array} result resulting intersection point will be stored here if intersection exists
- * @param {number} result_offset
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @return {boolean} True if segments intersect, False otherwise
- */
-export function segment2_segment_compute_intersection_array_2d(
-    result, result_offset,
-    a0_x, a0_y, a1_x, a1_y,
-    b0_x, b0_y, b1_x, b1_y
-) {
-
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-    const dy_02 = a0_y - b0_y;
-    const dx_02 = a0_x - b0_x;
-
-    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
-
-    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
-    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
-
-    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
-        // Collision detected
-
-        const intercept_x = a0_x + (t * s1_x);
-        const intercept_y = a0_y + (t * s1_y);
-
-        result[result_offset] = intercept_x;
-        result[result_offset + 1] = intercept_y;
-
-        return true;
-    }
-
-    return false; // No collision
-}
+import { segment2_segment_intersection_fractions } from "./segment2_segment_intersection_fractions.js";
+
+const scratch_fractions = new Float64Array(2);
+
+/**
+ *
+ * Find intersection point between two line segments if they intersect at all
+ * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
+ * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
+ *
+ * @param {number[]|Float32Array|Float64Array} result resulting intersection point will be stored here if intersection exists
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @return {boolean} True if segments intersect, False otherwise
+ */
+export function segment2_segment_compute_intersection_array_2d(
+    result, result_offset,
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y
+) {
+
+    const overlaps = segment2_segment_intersection_fractions(
+        scratch_fractions, 0,
+        a0_x, a0_y, a1_x, a1_y,
+        b0_x, b0_y, b1_x, b1_y
+    );
+
+    if (overlaps) {
+        // Collision detected -- reconstruct the point from the fraction along segment A
+        const t = scratch_fractions[1];
+
+        result[result_offset] = a0_x + t * (a1_x - a0_x);
+        result[result_offset + 1] = a0_y + t * (a1_y - a0_y);
+
+        return true;
+    }
+
+    return false; // No collision
+}

package/src/core/geom/2d/line/segment2_segment_intersection_fractions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Compute the parametric fractions at which two 2D segments meet, and report whether that meeting point
+ * lies within both segments.
+ *
+ * Writes `[s, t]` into `result`, where the intersection of the two supporting LINES sits at `s` along
+ * segment B and `t` along segment A — so the point itself is `a0 + t * (a1 - a0)`. Both fractions are
+ * written whether or not the segments actually overlap, so a caller that wants the line-line answer can
+ * ignore the return value.
+ *
+ * Shared core of {@link segment2_intersects_segment2_2d} (boolean) and
+ * {@link segment2_segment_compute_intersection_array_2d} (point-returning); those two previously carried
+ * byte-identical copies of this arithmetic.
+ *
+ * PARALLEL SEGMENTS: the denominator is zero, so `s` and `t` come out `±Infinity` or `NaN` and the range
+ * test is false. Exactly-collinear overlapping segments are therefore reported as non-intersecting — the
+ * historical behaviour of both callers, preserved here deliberately.
+ *
+ * @param {number[]|Float32Array|Float64Array} result destination for `[s, t]`
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} true when the segments genuinely overlap (both fractions inside `[0, 1]`)
+ */
+export function segment2_segment_intersection_fractions(result: number[] | Float32Array | Float64Array, result_offset: number, a0_x: number, a0_y: number, a1_x: number, a1_y: number, b0_x: number, b0_y: number, b1_x: number, b1_y: number): boolean;
+//# sourceMappingURL=segment2_segment_intersection_fractions.d.ts.map

package/src/core/geom/2d/line/segment2_segment_intersection_fractions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment2_segment_intersection_fractions.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_intersection_fractions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gEAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAwBnB"}

package/src/core/geom/2d/line/segment2_segment_intersection_fractions.js

@@ -0,0 +1,52 @@
+/**
+ * Compute the parametric fractions at which two 2D segments meet, and report whether that meeting point
+ * lies within both segments.
+ *
+ * Writes `[s, t]` into `result`, where the intersection of the two supporting LINES sits at `s` along
+ * segment B and `t` along segment A — so the point itself is `a0 + t * (a1 - a0)`. Both fractions are
+ * written whether or not the segments actually overlap, so a caller that wants the line-line answer can
+ * ignore the return value.
+ *
+ * Shared core of {@link segment2_intersects_segment2_2d} (boolean) and
+ * {@link segment2_segment_compute_intersection_array_2d} (point-returning); those two previously carried
+ * byte-identical copies of this arithmetic.
+ *
+ * PARALLEL SEGMENTS: the denominator is zero, so `s` and `t` come out `±Infinity` or `NaN` and the range
+ * test is false. Exactly-collinear overlapping segments are therefore reported as non-intersecting — the
+ * historical behaviour of both callers, preserved here deliberately.
+ *
+ * @param {number[]|Float32Array|Float64Array} result destination for `[s, t]`
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} true when the segments genuinely overlap (both fractions inside `[0, 1]`)
+ */
+export function segment2_segment_intersection_fractions(
+    result, result_offset,
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y
+) {
+    const s1_x = a1_x - a0_x;
+    const s1_y = a1_y - a0_y;
+    const s2_x = b1_x - b0_x;
+    const s2_y = b1_y - b0_y;
+
+    const dy_02 = a0_y - b0_y;
+    const dx_02 = a0_x - b0_x;
+
+    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
+
+    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
+    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
+
+    result[result_offset] = s;
+    result[result_offset + 1] = t;
+
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+}

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.d.ts

@@ -1,4 +1,9 @@
 /**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)`.
+ *
+ * The unfiltered face of {@link qt_match_data_by_circle}; the traversal previously existed twice,
+ * differing only by that query's extra `predicate` conjunct.
+ *
  * @template T
  * @param {Array<QuadTreeDatum<T>>} result
  * @param {number} result_offset
@@ -6,7 +11,7 @@
  * @param {number} x
  * @param {number} y
  * @param {number} radius
- * @returns {number}
+ * @returns {number} number of matches written
  */
 export function qt_collect_by_circle<T>(result: Array<QuadTreeDatum<T>>, result_offset: number, tree: QuadTreeNode<T>, x: number, y: number, radius: number): number;
 //# sourceMappingURL=qt_collect_by_circle.d.ts.map

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qt_collect_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_collect_by_circle.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,gDARW,uBAAuB,iBACvB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAgDlB"}
+{"version":3,"file":"qt_collect_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_collect_by_circle.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,gDARW,uBAAuB,iBACvB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAalB"}

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.js

@@ -1,65 +1,39 @@
-import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
-
-/**
- *
- * @type {QuadTreeNode[]}
- */
-const node_stack = [];
-
-/**
- * @template T
- * @param {Array<QuadTreeDatum<T>>} result
- * @param {number} result_offset
- * @param {QuadTreeNode<T>} tree
- * @param {number} x
- * @param {number} y
- * @param {number} radius
- * @returns {number}
- */
-export function qt_collect_by_circle(
-    result, result_offset,
-    tree,
-    x, y, radius
-) {
-    let result_cursor = result_offset;
-
-    let stack_pointer = 1;
-
-    const r2 = radius * radius;
-
-    node_stack[0] = tree;
-
-    while (stack_pointer-- > 0) {
-
-        const node = node_stack[stack_pointer];
-
-        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
-
-        if (d2 > r2) {
-            // not a match
-            continue;
-        }
-
-        const data = node.data;
-        const data_count = data.length;
-
-        for (let i = 0; i < data_count; i++) {
-            const datum = data[i];
-
-            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
-
-            if (d2_to_datum <= r2) {
-                result[result_cursor++] = datum;
-            }
-        }
-
-        if (node.isSplit()) {
-            node_stack[stack_pointer++] = node.topLeft;
-            node_stack[stack_pointer++] = node.bottomLeft;
-            node_stack[stack_pointer++] = node.topRight;
-            node_stack[stack_pointer++] = node.bottomRight;
-        }
-    }
-
-    return result_cursor - result_offset;
-}
+import { qt_match_data_by_circle } from "./qt_match_data_by_circle.js";
+
+/**
+ * Accept every datum. A real function rather than a null/undefined sentinel, so
+ * {@link qt_match_data_by_circle} has exactly one control-flow path.
+ *
+ * @returns {boolean}
+ */
+function accept_all() {
+    return true;
+}
+
+/**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)`.
+ *
+ * The unfiltered face of {@link qt_match_data_by_circle}; the traversal previously existed twice,
+ * differing only by that query's extra `predicate` conjunct.
+ *
+ * @template T
+ * @param {Array<QuadTreeDatum<T>>} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @returns {number} number of matches written
+ */
+export function qt_collect_by_circle(
+    result, result_offset,
+    tree,
+    x, y, radius
+) {
+    return qt_match_data_by_circle(
+        result, result_offset,
+        tree,
+        x, y, radius,
+        accept_all, undefined
+    );
+}

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.d.ts

@@ -1,14 +1,24 @@
 /**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)` AND satisfy `predicate`.
+ *
+ * Also the implementation behind {@link qt_collect_by_circle}, which is this query with an
+ * accept-everything predicate — the traversal was previously written out twice, differing only by the
+ * `predicate.call(...)` conjunct.
+ *
+ * Children are pruned on PUSH (against the circle's bounding square) as well as tested on POP, matching
+ * {@link qt_collect_by_box}. Testing only on pop still returns the right answer but walks and re-tests
+ * quadrants the circle cannot reach.
+ *
  * @template T
- * @param {QuadTreeDatum<T>[]} result
+ * @param {Array<QuadTreeDatum<T>>} result
  * @param {number} result_offset
  * @param {QuadTreeNode<T>} tree
  * @param {number} x
  * @param {number} y
  * @param {number} radius
- * @param {function(data:T):boolean} [predicate]
- * @param {*} [predicateContext]
- * @returns {number}
+ * @param {function(T):boolean} predicate
+ * @param {*} [predicateContext] `this` for `predicate`
+ * @returns {number} number of matches written
  */
-export function qt_match_data_by_circle<T>(result: QuadTreeDatum<T>[], result_offset: number, tree: QuadTreeNode<T>, x: number, y: number, radius: number, predicate: any, predicateContext?: any): number;
+export function qt_match_data_by_circle<T>(result: Array<QuadTreeDatum<T>>, result_offset: number, tree: QuadTreeNode<T>, x: number, y: number, radius: number, predicate: (arg0: T) => boolean, predicateContext?: any): number;
 //# sourceMappingURL=qt_match_data_by_circle.d.ts.map

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qt_match_data_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_match_data_by_circle.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,mDAVW,kBAAkB,iBAClB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,2CAGJ,MAAM,CAmDlB"}
+{"version":3,"file":"qt_match_data_by_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_match_data_by_circle.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mDAVW,uBAAuB,iBACvB,MAAM,4BAEN,MAAM,KACN,MAAM,UACN,MAAM,0BACM,OAAO,2BAEjB,MAAM,CAyElB"}

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.js

@@ -1,70 +1,101 @@
-import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
-
-/**
- *
- * @type {QuadTreeNode[]}
- */
-const node_stack = [];
-
-/**
- * @template T
- * @param {QuadTreeDatum<T>[]} result
- * @param {number} result_offset
- * @param {QuadTreeNode<T>} tree
- * @param {number} x
- * @param {number} y
- * @param {number} radius
- * @param {function(data:T):boolean} [predicate]
- * @param {*} [predicateContext]
- * @returns {number}
- */
-export function qt_match_data_by_circle(
-    result, result_offset,
-    tree,
-    x, y, radius,
-    predicate, predicateContext
-) {
-    let result_cursor = result_offset;
-
-    let stack_pointer = 0;
-
-    const r2 = radius * radius;
-
-    node_stack[stack_pointer] = tree;
-    stack_pointer++;
-
-    while (stack_pointer > 0) {
-
-        --stack_pointer;
-        const node = node_stack[stack_pointer];
-
-        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
-
-        if (d2 > r2) {
-            // not a match
-            continue;
-        }
-
-        const data = node.data;
-        const data_count = data.length;
-
-        for (let i = 0; i < data_count; i++) {
-            const datum = data[i];
-
-            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
-
-            if (d2_to_datum <= r2 && predicate.call(predicateContext, datum.data)) {
-                result[result_cursor++] = datum;
-            }
-        }
-
-        if (node.isSplit()) {
-            node_stack[stack_pointer++] = node.topLeft;
-            node_stack[stack_pointer++] = node.bottomLeft;
-            node_stack[stack_pointer++] = node.topRight;
-            node_stack[stack_pointer++] = node.bottomRight;
-        }
-    }
-
-    return result_cursor - result_offset;
-}
+import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
+
+/**
+ * @type {QuadTreeNode[]}
+ */
+const node_stack = [];
+
+/**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)` AND satisfy `predicate`.
+ *
+ * Also the implementation behind {@link qt_collect_by_circle}, which is this query with an
+ * accept-everything predicate — the traversal was previously written out twice, differing only by the
+ * `predicate.call(...)` conjunct.
+ *
+ * Children are pruned on PUSH (against the circle's bounding square) as well as tested on POP, matching
+ * {@link qt_collect_by_box}. Testing only on pop still returns the right answer but walks and re-tests
+ * quadrants the circle cannot reach.
+ *
+ * @template T
+ * @param {Array<QuadTreeDatum<T>>} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @param {function(T):boolean} predicate
+ * @param {*} [predicateContext] `this` for `predicate`
+ * @returns {number} number of matches written
+ */
+export function qt_match_data_by_circle(
+    result, result_offset,
+    tree,
+    x, y, radius,
+    predicate, predicateContext
+) {
+    let result_cursor = result_offset;
+
+    let stack_pointer = 0;
+
+    const r2 = radius * radius;
+
+    // bounding square of the query circle, used to prune quadrants on push
+    const query_x0 = x - radius;
+    const query_y0 = y - radius;
+    const query_x1 = x + radius;
+    const query_y1 = y + radius;
+
+    node_stack[stack_pointer] = tree;
+    stack_pointer++;
+
+    while (stack_pointer > 0) {
+
+        --stack_pointer;
+        const node = node_stack[stack_pointer];
+
+        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
+
+        if (d2 > r2) {
+            // not a match
+            continue;
+        }
+
+        const data = node.data;
+        const data_count = data.length;
+
+        for (let i = 0; i < data_count; i++) {
+            const datum = data[i];
+
+            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+
+            if (d2_to_datum <= r2 && predicate.call(predicateContext, datum.data)) {
+                result[result_cursor++] = datum;
+            }
+        }
+
+        if (node.isSplit()) {
+            const hx = (node.x0 + node.x1) * 0.5;
+            const hy = (node.y0 + node.y1) * 0.5;
+
+            if (hx >= query_x0) {
+                if (hy >= query_y0) {
+                    node_stack[stack_pointer++] = node.topLeft;
+                }
+                if (hy <= query_y1) {
+                    node_stack[stack_pointer++] = node.bottomLeft;
+                }
+            }
+
+            if (hx <= query_x1) {
+                if (hy >= query_y0) {
+                    node_stack[stack_pointer++] = node.topRight;
+                }
+                if (hy <= query_y1) {
+                    node_stack[stack_pointer++] = node.bottomRight;
+                }
+            }
+        }
+    }
+
+    return result_cursor - result_offset;
+}

package/src/core/geom/2d/quad-tree/qt_query_data_raycast.d.ts

@@ -6,9 +6,9 @@
  * @param {number} direction_x
  * @param {number} direction_y
  * @param {number} max_distance
- * @param {function(data:T, origin_x:number, origin_y:number, direction_x:number, direction_y:number, max_distance2:number):boolean} [predicate]
+ * @param {(data: T, origin_x: number, origin_y: number, direction_x: number, direction_y: number, max_distance2: number) => boolean} [predicate]
  * @param {*} [predicateContext]
  * @returns {QuadTreeDatum<T>|undefined}
  */
-export function qt_query_data_raycast<T>(tree: QuadTreeNode<T>, origin_x: number, origin_y: number, direction_x: number, direction_y: number, max_distance: number, predicate: any, predicateContext?: any): QuadTreeDatum<T> | undefined;
+export function qt_query_data_raycast<T>(tree: QuadTreeNode<T>, origin_x: number, origin_y: number, direction_x: number, direction_y: number, max_distance: number, predicate?: (data: T, origin_x: number, origin_y: number, direction_x: number, direction_y: number, max_distance2: number) => boolean, predicateContext?: any): QuadTreeDatum<T> | undefined;
 //# sourceMappingURL=qt_query_data_raycast.d.ts.map

package/src/core/geom/2d/quad-tree/qt_query_data_raycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qt_query_data_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_query_data_raycast.js"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH,0EATW,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,2CAGJ,mBAAiB,SAAS,CA6EtC"}
+{"version":3,"file":"qt_query_data_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_query_data_raycast.js"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH,0EATW,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,kCACc,MAAM,YAAY,MAAM,eAAe,MAAM,eAAe,MAAM,iBAAiB,MAAM,KAAK,OAAO,2BAEvH,mBAAiB,SAAS,CA6EtC"}

package/src/core/geom/2d/quad-tree/qt_query_data_raycast.js

@@ -15,7 +15,7 @@ const node_stack = [];
  * @param {number} direction_x
  * @param {number} direction_y
  * @param {number} max_distance
- * @param {function(data:T, origin_x:number, origin_y:number, direction_x:number, direction_y:number, max_distance2:number):boolean} [predicate]
+ * @param {(data: T, origin_x: number, origin_y: number, direction_x: number, direction_y: number, max_distance2: number) => boolean} [predicate]
  * @param {*} [predicateContext]
  * @returns {QuadTreeDatum<T>|undefined}
  */

package/src/core/geom/2d/r-tree/StaticR2Tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAgFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAuEC;CACJ"}
+{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAoFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAuEC;CACJ"}

package/src/core/geom/2d/r-tree/StaticR2Tree.js

@@ -219,12 +219,16 @@ export class StaticR2Tree {
         const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
         const stack_top = stack.pointer;
 
-        let stackPointer = stack_top + 2;
+        let stackPointer = stack_top;
         let iL, iR;
 
 
-        stack[0] = 0; // first node
-        stack[1] = this.__node_count_leaf - 1; // last node
+        // seed RELATIVE to stack_top: SCRATCH_UINT32_TRAVERSAL_STACK is shared, so an outer traversal may
+        // already own the low slots. Writing the seed to absolute 0/1 while reading from stack_top made
+        // this read another traversal's frame whenever it ran nested. BinaryUint32BVH, which this was
+        // forked from, always seeded relative.
+        stack[stackPointer++] = 0; // first node
+        stack[stackPointer++] = this.__node_count_leaf - 1; // last node
 
         const data = this.__data_float32;