@woosh/meep-engine 3.38.0 → 3.40.0

package/src/engine/physics/island/IslandBuilder.js

@@ -5,6 +5,34 @@ import { body_is_wholly_sensor } from "../ecs/is_sensor.js";
 import { JOINT_WORLD } from "../ecs/Joint.js";
 import { uf_find, uf_init, uf_union } from "../../../core/collection/union-find/union_find.js";
 
+/**
+ * A union-find parent table of `n` entries with every node its own root.
+ * @param {number} n
+ * @returns {Uint32Array}
+ */
+function identity_uint32(n) {
+    const parent = new Uint32Array(n);
+    uf_init(parent, n);
+    return parent;
+}
+
+/**
+ * Island contact slices up to this length are sorted in place by the plain
+ * insertion sort; longer ones by the keyed merge sort. Measured: on input in
+ * random entity order the keyed sort draws level at 4 contacts and is 1.4x
+ * faster at 16; on input already in order the two stay level to ~32 and the
+ * plain sort leads beyond. Below ~8 they are within a few ns either way.
+ * @type {number}
+ */
+const CONTACT_SORT_INSERTION_MAX = 8;
+
+/**
+ * Length of the runs the keyed merge sort insertion-sorts (on gathered keys)
+ * before its first merge pass.
+ * @type {number}
+ */
+const CONTACT_SORT_RUN = 16;
+
 /**
  * Partitions this frame's awake dynamic bodies + contacting non-sensor
  * manifolds into connected components ("islands") via union-find. The solver iterates
@@ -53,17 +81,18 @@ export class IslandBuilder {
     /**
      * Union-find parent table, indexed by body index (NOT packed id).
      * Sized to `storage.high_water_mark` at `build` time; reallocated by
-     * doubling when the body pool grows past current capacity.
+     * doubling when the body pool grows past current capacity. Every body is
+     * its own root except those the last build united.
      * @type {Uint32Array}
      */
-    parent = new Uint32Array(16);
+    parent = identity_uint32(16);
 
     /**
      * Per-body island id. `island_of_body[idx] === -1` means the body
      * is not in any island this frame (static, kinematic, or unallocated).
      * @type {Int32Array}
      */
-    island_of_body = new Int32Array(16);
+    island_of_body = new Int32Array(16).fill(-1);
 
     /**
      * Number of islands this frame.
@@ -100,8 +129,8 @@ export class IslandBuilder {
     contact_offsets = new Uint32Array(2);
 
     /**
-     * Flattened manifold slot ids, grouped by island, sorted ascending
-     * within each island.
+     * Flattened manifold slot ids, grouped by island, sorted by canonical
+     * entity pair within each island (see the class doc).
      * @type {Uint32Array}
      */
     contact_data = new Uint32Array(16);
@@ -114,11 +143,51 @@ export class IslandBuilder {
 
     /**
      * Scratch: root body index → island id, or -1 if unassigned.
-     * Sized in lockstep with `parent`.
+     * Sized in lockstep with `parent`. -1 everywhere between builds: a build
+     * puts back the roots it wrote.
      * @private
      * @type {Int32Array}
      */
-    __root_to_island = new Int32Array(16);
+    __root_to_island = new Int32Array(16).fill(-1);
+
+    /**
+     * Scratch: the body indices whose `parent` entry the last build may have
+     * changed — every index it handed to the union-find — so the next build
+     * can put just those back to their own roots. Sized in lockstep with
+     * `parent`; `__uf_touched_count` valid entries.
+     *
+     * This and the generation stamps below keep a build's cost proportional to
+     * the bodies and contacts it sees, not to the body-slot high-water mark:
+     * re-initialising `parent`, `island_of_body` and `__root_to_island` over
+     * every slot made a build cost over a millisecond at a million slots with
+     * ten bodies awake; it costs 0.009 ms now.
+     * @private
+     * @type {Uint32Array}
+     */
+    __uf_touched = new Uint32Array(16);
+
+    /**
+     * @private
+     * @type {number}
+     */
+    __uf_touched_count = 0;
+
+    /**
+     * Scratch: per body index, the build generation that last recorded it in
+     * {@link __uf_touched}, so each index is recorded once a build. Sized in
+     * lockstep with `parent`.
+     * @private
+     * @type {Int32Array}
+     */
+    __uf_stamp = new Int32Array(16);
+
+    /**
+     * Current build generation for {@link __uf_stamp}; never 0 once a build
+     * has begun, so a fresh (zeroed) stamp never reads as recorded.
+     * @private
+     * @type {number}
+     */
+    __uf_generation = 0;
 
     /**
      * Scratch: list of distinct root indices observed this frame, used
@@ -135,6 +204,47 @@ export class IslandBuilder {
      */
     __cursors = new Uint32Array(2);
 
+    /**
+     * Scratch for the keyed merge sort of long island contact slices: per
+     * element, the canonical entity pair (lo, hi) and the slot id, in two
+     * ping-pong banks. Empty until a slice longer than
+     * {@link CONTACT_SORT_INSERTION_MAX} is seen, then grown by doubling to the
+     * longest slice so far.
+     * @private
+     * @type {Int32Array}
+     */
+    __sort_lo = new Int32Array(0);
+
+    /**
+     * @private
+     * @type {Int32Array}
+     */
+    __sort_hi = new Int32Array(0);
+
+    /**
+     * @private
+     * @type {Uint32Array}
+     */
+    __sort_slot = new Uint32Array(0);
+
+    /**
+     * @private
+     * @type {Int32Array}
+     */
+    __sort_lo_swap = new Int32Array(0);
+
+    /**
+     * @private
+     * @type {Int32Array}
+     */
+    __sort_hi_swap = new Int32Array(0);
+
+    /**
+     * @private
+     * @type {Uint32Array}
+     */
+    __sort_slot_swap = new Uint32Array(0);
+
     /**
      * @param {RigidBody} rb
      * @param {Array} collider_list collider list for the body (or undefined)
@@ -165,8 +275,29 @@ export class IslandBuilder {
         const hwm = storage.high_water_mark;
         this.__ensure_body_capacity(hwm);
 
+        // Undo the last build where it wrote, rather than re-initialising every
+        // slot: its unions in `parent`, its island ids in `island_of_body` (the
+        // bodies it emitted — exactly the ones it gave an id).
         const parent = this.parent;
-        uf_init(parent, hwm);
+        const touched = this.__uf_touched;
+        for (let i = 0; i < this.__uf_touched_count; i++) {
+            const idx = touched[i];
+            parent[idx] = idx;
+        }
+        this.__uf_touched_count = 0;
+
+        const island_of_body = this.island_of_body;
+        const prior_body_data = this.body_data;
+        const prior_body_total = this.body_total;
+        for (let i = 0; i < prior_body_total; i++) {
+            island_of_body[prior_body_data[i]] = -1;
+        }
+
+        // Only a union makes a `parent` entry other than its own index, and
+        // path halving rewrites only entries a union already made non-roots,
+        // so recording each union's two bodies covers every entry this build
+        // can change. A lone body's lookup reads its own entry and stops.
+        this.__next_uf_generation();
 
         // --- Pass 1: union dynamic-dynamic pairs from CONTACTING non-sensor
         //     manifolds. The contact_count gate matters: a touched slot with
@@ -186,6 +317,8 @@ export class IslandBuilder {
             if (IslandBuilder.__body_is_sensor(rbA, body_collider_lists[idxA])) continue;
             if (IslandBuilder.__body_is_sensor(rbB, body_collider_lists[idxB])) continue;
             if (rbA.kind === BodyKind.Dynamic && rbB.kind === BodyKind.Dynamic) {
+                this.__uf_touch(idxA);
+                this.__uf_touch(idxB);
                 uf_union(parent, idxA, idxB);
             }
         }
@@ -209,17 +342,17 @@ export class IslandBuilder {
             const rbB = bodies[idxB];
             if (rbA === undefined || rbB === undefined) continue;
             if (rbA.kind === BodyKind.Dynamic && rbB.kind === BodyKind.Dynamic) {
+                this.__uf_touch(idxA);
+                this.__uf_touch(idxB);
                 uf_union(parent, idxA, idxB);
             }
         }
 
         // --- Pass 2: collect distinct roots over awake dynamic bodies.
-        const island_of_body = this.island_of_body;
-        // Cheap reset: only the indices we may write are below hwm.
-        for (let i = 0; i < hwm; i++) island_of_body[i] = -1;
-
+        // `island_of_body` and `__root_to_island` are -1 everywhere here: the
+        // top of this build undid the last one's ids, and the last build put
+        // back the roots it wrote.
         const root_to_island = this.__root_to_island;
-        for (let i = 0; i < hwm; i++) root_to_island[i] = -1;
 
         const awake_count = storage.awake_count;
         const scratch_roots = this.__scratch_roots;
@@ -256,6 +389,10 @@ export class IslandBuilder {
             island_of_body[idx] = root_to_island[r];
         }
 
+        for (let i = 0; i < root_count; i++) {
+            root_to_island[scratch_roots[i]] = -1;
+        }
+
         this.__build_body_csr(storage, bodies, awake_count, root_count);
         this.__build_contact_csr(storage, manifolds, bodies, body_collider_lists, root_count);
     }
@@ -360,17 +497,130 @@ export class IslandBuilder {
             const start = offsets[i];
             const end = offsets[i + 1];
             if (end - start > 1) {
-                IslandBuilder.__sort_slots_by_entity_pair(data, start, end, storage, manifolds);
+                this.__sort_contact_slice(data, start, end, storage, manifolds);
             }
         }
     }
 
+    /**
+     * Sort `data[start..end)` (manifold slot ids) by canonical entity pair,
+     * producing exactly the order {@link __sort_slots_by_entity_pair} produces,
+     * for every input.
+     *
+     * Short slices go to that insertion sort. A connected pile is one island
+     * whose contacts arrive in manifold slot order, which is unrelated to entity
+     * order (inversions ≈ n²/4), so the insertion sort was quadratic there:
+     * 2,464 contacts in one island took 6.0 ms a step, 5,190 took 24 ms.
+     * Longer slices gather each slot's (lo, hi) key once and run a bottom-up
+     * merge sort over the retained scratch banks — O(n log n), no allocation
+     * once the banks have grown.
+     *
+     * Both sorts are stable (the insertion shifts only past strictly greater
+     * keys; the merge takes the left run on ties), and a stable sort's output is
+     * determined by the keys and the input order alone, so the two agree element
+     * for element — duplicate keys included, though a frame holds one slot per
+     * pair.
+     *
+     * @private
+     * @param {Uint32Array} data
+     * @param {number} start
+     * @param {number} end exclusive
+     * @param {BodyStorage} storage
+     * @param {ManifoldStore} manifolds
+     */
+    __sort_contact_slice(data, start, end, storage, manifolds) {
+        const n = end - start;
+        if (n <= CONTACT_SORT_INSERTION_MAX) {
+            IslandBuilder.__sort_slots_by_entity_pair(data, start, end, storage, manifolds);
+            return;
+        }
+
+        this.__ensure_sort_capacity(n);
+
+        let src_lo = this.__sort_lo;
+        let src_hi = this.__sort_hi;
+        let src_slot = this.__sort_slot;
+        let dst_lo = this.__sort_lo_swap;
+        let dst_hi = this.__sort_hi_swap;
+        let dst_slot = this.__sort_slot_swap;
+
+        // Gather keys, insertion-sorting each CONTACT_SORT_RUN-long run as it fills.
+        for (let i = 0; i < n; i++) {
+            const slot = data[start + i];
+            const ea = storage.entity_at(body_id_index(manifolds.bodyA(slot)));
+            const eb = storage.entity_at(body_id_index(manifolds.bodyB(slot)));
+            const lo = ea < eb ? ea : eb;
+            const hi = ea < eb ? eb : ea;
+
+            const run_start = i - i % CONTACT_SORT_RUN;
+            let j = i - 1;
+            while (j >= run_start) {
+                const o_lo = src_lo[j];
+                if (o_lo < lo || (o_lo === lo && src_hi[j] <= hi)) break;
+                src_lo[j + 1] = o_lo;
+                src_hi[j + 1] = src_hi[j];
+                src_slot[j + 1] = src_slot[j];
+                j--;
+            }
+            src_lo[j + 1] = lo;
+            src_hi[j + 1] = hi;
+            src_slot[j + 1] = slot;
+        }
+
+        // Bottom-up merge passes, ping-ponging between the banks.
+        for (let width = CONTACT_SORT_RUN; width < n; width *= 2) {
+            for (let left = 0; left < n; left += 2 * width) {
+                const mid = left + width < n ? left + width : n;
+                const right_end = left + 2 * width < n ? left + 2 * width : n;
+                let a = left;
+                let b = mid;
+                let k = left;
+                while (a < mid && b < right_end) {
+                    const a_lo = src_lo[a];
+                    const b_lo = src_lo[b];
+                    // Right only when strictly smaller: ties keep the left run first.
+                    if (b_lo < a_lo || (b_lo === a_lo && src_hi[b] < src_hi[a])) {
+                        dst_lo[k] = b_lo;
+                        dst_hi[k] = src_hi[b];
+                        dst_slot[k] = src_slot[b];
+                        b++;
+                    } else {
+                        dst_lo[k] = a_lo;
+                        dst_hi[k] = src_hi[a];
+                        dst_slot[k] = src_slot[a];
+                        a++;
+                    }
+                    k++;
+                }
+                for (; a < mid; a++, k++) {
+                    dst_lo[k] = src_lo[a];
+                    dst_hi[k] = src_hi[a];
+                    dst_slot[k] = src_slot[a];
+                }
+                for (; b < right_end; b++, k++) {
+                    dst_lo[k] = src_lo[b];
+                    dst_hi[k] = src_hi[b];
+                    dst_slot[k] = src_slot[b];
+                }
+            }
+
+            const t_lo = src_lo; src_lo = dst_lo; dst_lo = t_lo;
+            const t_hi = src_hi; src_hi = dst_hi; dst_hi = t_hi;
+            const t_slot = src_slot; src_slot = dst_slot; dst_slot = t_slot;
+        }
+
+        for (let i = 0; i < n; i++) {
+            data[start + i] = src_slot[i];
+        }
+    }
+
     /**
      * In-place insertion sort of `data[start..end)` (manifold slot ids) by the
      * canonical entity pair `(min(entA, entB), max(entA, entB))` of each slot.
      * One slot per pair, so the key is unique within a frame and the order is
-     * total. Insertion sort: island contact slices are small (tens), the
-     * comparator is two table reads, and there is nothing to allocate.
+     * total. Insertion sort: used for short slices only (see
+     * {@link __sort_contact_slice}), where re-reading the keys per compare is
+     * cheaper than gathering them, and there is nothing to allocate.
      *
      * @private
      * @param {Uint32Array} data
@@ -465,10 +715,47 @@ export class IslandBuilder {
     __ensure_body_capacity(n) {
         if (this.parent.length < n) {
             const cap = ceilPowerOfTwo(n);
-            this.parent = new Uint32Array(cap);
-            this.island_of_body = new Int32Array(cap);
-            this.__root_to_island = new Int32Array(cap);
+
+            // Fresh tables start in the between-builds state — every body its
+            // own root, no island ids, no roots recorded — so there is nothing
+            // of the last build left to undo.
+            this.parent = identity_uint32(cap);
+            this.island_of_body = new Int32Array(cap).fill(-1);
+            this.__root_to_island = new Int32Array(cap).fill(-1);
             this.__scratch_roots = new Uint32Array(cap);
+            this.__uf_touched = new Uint32Array(cap);
+            this.__uf_touched_count = 0;
+            this.__uf_stamp = new Int32Array(cap);
+        }
+    }
+
+    /**
+     * Roll the build generation for {@link __uf_stamp}; on (astronomically
+     * unlikely) Int32 wrap, clear the stamps so a recycled generation value
+     * can't read as already recorded. Same scheme as SolverBodyState#begin.
+     * @private
+     */
+    __next_uf_generation() {
+        const next = (this.__uf_generation + 1) | 0;
+        if (next <= 0) {
+            this.__uf_stamp.fill(0);
+            this.__uf_generation = 1;
+        } else {
+            this.__uf_generation = next;
+        }
+    }
+
+    /**
+     * Record that this build hands body index `idx` to the union-find, once.
+     * @private
+     * @param {number} idx
+     */
+    __uf_touch(idx) {
+        const stamp = this.__uf_stamp;
+        const generation = this.__uf_generation;
+        if (stamp[idx] !== generation) {
+            stamp[idx] = generation;
+            this.__uf_touched[this.__uf_touched_count++] = idx;
         }
     }
 
@@ -504,4 +791,20 @@ export class IslandBuilder {
             this.contact_data = new Uint32Array(ceilPowerOfTwo(n));
         }
     }
+
+    /**
+     * @private
+     * @param {number} n
+     */
+    __ensure_sort_capacity(n) {
+        if (this.__sort_lo.length < n) {
+            const cap = ceilPowerOfTwo(n);
+            this.__sort_lo = new Int32Array(cap);
+            this.__sort_hi = new Int32Array(cap);
+            this.__sort_slot = new Uint32Array(cap);
+            this.__sort_lo_swap = new Int32Array(cap);
+            this.__sort_hi_swap = new Int32Array(cap);
+            this.__sort_slot_swap = new Uint32Array(cap);
+        }
+    }
 }

package/src/engine/physics/narrowphase/box_box_manifold.d.ts

@@ -24,6 +24,19 @@
  * @returns {boolean} true if overlap
  */
 export function box_box_manifold(out: number[] | Float64Array, ax: number, ay: number, az: number, aqx: number, aqy: number, aqz: number, aqw: number, ahx: number, ahy: number, ahz: number, bx: number, by: number, bz: number, bqx: number, bqy: number, bqz: number, bqw: number, bhx: number, bhy: number, bhz: number): boolean;
+/**
+ * {@link box_box_manifold} with each box read from an array: centre (world), orientation (unit
+ * quaternion), half-extents (body frame), ten numbers. A call V8 does not inline boxes each number
+ * passed to it, twenty here, once per box pair per step.
+ *
+ * @param {number[]|Float64Array} out length >= BOX_BOX_OUT_LENGTH
+ * @param {Float64Array} box_a
+ * @param {number} box_a_offset
+ * @param {Float64Array} box_b
+ * @param {number} box_b_offset
+ * @returns {boolean} true if overlap
+ */
+export function box_box_manifold_array(out: number[] | Float64Array, box_a: Float64Array, box_a_offset: number, box_b: Float64Array, box_b_offset: number): boolean;
 /**
  * Length of `out` required by {@link box_box_manifold}.
  * @type {number}

package/src/engine/physics/narrowphase/box_box_manifold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"box_box_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_box_manifold.js"],"names":[],"mappings":"AA2JA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAvBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CA8enB;AA9lBD;;;GAGG;AACH,iCAFU,MAAM,CAEoD"}
+{"version":3,"file":"box_box_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_box_manifold.js"],"names":[],"mappings":"AA4KA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAvBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAmBnB;AAMD;;;;;;;;;;;GAWG;AACH,4CAPW,MAAM,EAAE,GAAC,YAAY,SACrB,YAAY,gBACZ,MAAM,SACN,YAAY,gBACZ,MAAM,GACJ,OAAO,CAkfnB;AAtpBD;;;GAGG;AACH,iCAFU,MAAM,CAEoD"}

package/src/engine/physics/narrowphase/box_box_manifold.js

@@ -1,5 +1,5 @@
 import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
-import { quat3_to_matrix3 } from "../../../core/geom/3d/quaternion/quat3_to_matrix3.js";
+import { quat3_to_matrix3_array } from "../../../core/geom/3d/quaternion/quat3_to_matrix3.js";
 import { polygon2_clip_axis_halfplane } from "../../../core/geom/2d/polygon/polygon2_clip_axis_halfplane.js";
 import { reduce_manifold_contacts } from "./reduce_manifold_contacts.js";
 import { box3_projected_half_extent } from "../../../core/geom/3d/box/box3_projected_half_extent.js";
@@ -98,23 +98,40 @@ const scratch_edge_st = new Float64Array(2);
 // `test_axis` used to be a per-call closure inside box_box_manifold —
 // allocated for every box-box pair because it captures and MUTATES the
 // running best-axis accumulator. Hoisted to module scope with the per-pair
-// inputs staged in the g_bb_* slots below (written once per pair, read by
-// all 15 axis tests). Same arithmetic, same order — bit-identical results.
-
-let g_bb_ahx = 0, g_bb_ahy = 0, g_bb_ahz = 0;
-let g_bb_bhx = 0, g_bb_bhy = 0, g_bb_bhz = 0;
-let g_bb_dx = 0, g_bb_dy = 0, g_bb_dz = 0;
-let g_bb_best_overlap = Infinity;
-let g_bb_best_nx = 0, g_bb_best_ny = 0, g_bb_best_nz = 0;
+// inputs staged in `bb` below (written once per pair, read by all 15 axis
+// tests). Same arithmetic, same order — bit-identical results.
+//
+// `bb` is a Float64Array rather than module-level `let`s: a number written to
+// a module-level binding is boxed into a new heap object on every write, and
+// these are written per pair and per improving axis.
+
+const BB_A_HALF = 0;        // A's half-extents (3)
+const BB_B_HALF = 3;        // B's half-extents (3)
+const BB_D = 6;             // centre offset B − A (3)
+const BB_BEST_OVERLAP = 9;
+const BB_BEST_NORMAL = 10;  // unit, B → A (3)
+const BB_EDGE_AXIS = 13;    // an edge-pair candidate axis for test_axis (3)
+const BB_LENGTH = 16;
+
+const bb = new Float64Array(BB_LENGTH);
 let g_bb_best_source = -1;
 
 /**
  * SAT interval test of one candidate axis. Returns `true` when the axis
  * SEPARATES the boxes (caller bails). Tracks the minimum-overlap axis in
- * the g_bb_best_* slots, with the tie-break deadband documented at
- * {@link TIE_REL}.
+ * the `bb` best slots and {@link g_bb_best_source}, with the tie-break
+ * deadband documented at {@link TIE_REL}.
+ *
+ * The axis is read from an array: not every one of the fifteen calls is
+ * inlined, and a call that is not boxes each number passed to it.
+ *
+ * @param {Float64Array} axis
+ * @param {number} axis_offset the candidate axis, not necessarily unit
+ * @param {number} source 0..2 A's face axes, 3..5 B's, 6 + 3i + j the cross of A's axis i and B's j
+ * @returns {boolean}
  */
-function test_axis(lx, ly, lz, source) {
+function test_axis(axis, axis_offset, source) {
+    const lx = axis[axis_offset], ly = axis[axis_offset + 1], lz = axis[axis_offset + 2];
     const len_sqr = lx * lx + ly * ly + lz * lz;
 
     if (len_sqr < PARALLEL_EPS_SQR){
@@ -127,10 +144,10 @@ function test_axis(lx, ly, lz, source) {
     const uy = ly * inv_len;
     const uz = lz * inv_len;
 
-    const rA = box3_projected_half_extent(scratch_axes_a, 0, g_bb_ahx, g_bb_ahy, g_bb_ahz, ux, uy, uz);
-    const rB = box3_projected_half_extent(scratch_axes_b, 0, g_bb_bhx, g_bb_bhy, g_bb_bhz, ux, uy, uz);
+    const rA = box3_projected_half_extent(scratch_axes_a, 0, bb[BB_A_HALF], bb[BB_A_HALF + 1], bb[BB_A_HALF + 2], ux, uy, uz);
+    const rB = box3_projected_half_extent(scratch_axes_b, 0, bb[BB_B_HALF], bb[BB_B_HALF + 1], bb[BB_B_HALF + 2], ux, uy, uz);
 
-    const proj = g_bb_dx * ux + g_bb_dy * uy + g_bb_dz * uz;
+    const proj = bb[BB_D] * ux + bb[BB_D + 1] * uy + bb[BB_D + 2] * uz;
     const dist = proj < 0 ? -proj : proj;
     const overlap = (rA + rB) - dist;
 
@@ -142,12 +159,12 @@ function test_axis(lx, ly, lz, source) {
     // if it reduces the overlap past the hysteresis band. This biases ties
     // toward earlier-tested axes (A faces > B faces > edges) so aligned
     // boxes pick a stable reference instead of flip-flopping on noise.
-    if (g_bb_best_source === -1 || overlap < g_bb_best_overlap - (g_bb_best_overlap * TIE_REL + TIE_ABS)) {
-        g_bb_best_overlap = overlap;
+    if (g_bb_best_source === -1 || overlap < bb[BB_BEST_OVERLAP] - (bb[BB_BEST_OVERLAP] * TIE_REL + TIE_ABS)) {
+        bb[BB_BEST_OVERLAP] = overlap;
         const sign = proj > 0 ? -1 : 1; // normal points B->A
-        g_bb_best_nx = ux * sign;
-        g_bb_best_ny = uy * sign;
-        g_bb_best_nz = uz * sign;
+        bb[BB_BEST_NORMAL] = ux * sign;
+        bb[BB_BEST_NORMAL + 1] = uy * sign;
+        bb[BB_BEST_NORMAL + 2] = uz * sign;
         g_bb_best_source = source;
     }
     return false;
@@ -183,8 +200,45 @@ export function box_box_manifold(
     ax, ay, az, aqx, aqy, aqz, aqw, ahx, ahy, ahz,
     bx, by, bz, bqx, bqy, bqz, bqw, bhx, bhy, bhz
 ) {
-    quat3_to_matrix3(scratch_axes_a, 0, aqx, aqy, aqz, aqw);
-    quat3_to_matrix3(scratch_axes_b, 0, bqx, bqy, bqz, bqw);
+    const a = scratch_box_a;
+    const b = scratch_box_b;
+
+    a[0] = ax; a[1] = ay; a[2] = az;
+    a[3] = aqx; a[4] = aqy; a[5] = aqz; a[6] = aqw;
+    a[7] = ahx; a[8] = ahy; a[9] = ahz;
+
+    b[0] = bx; b[1] = by; b[2] = bz;
+    b[3] = bqx; b[4] = bqy; b[5] = bqz; b[6] = bqw;
+    b[7] = bhx; b[8] = bhy; b[9] = bhz;
+
+    return box_box_manifold_array(out, a, 0, b, 0);
+}
+
+/** Where {@link box_box_manifold} packs its two boxes. */
+const scratch_box_a = new Float64Array(10);
+const scratch_box_b = new Float64Array(10);
+
+/**
+ * {@link box_box_manifold} with each box read from an array: centre (world), orientation (unit
+ * quaternion), half-extents (body frame), ten numbers. A call V8 does not inline boxes each number
+ * passed to it, twenty here, once per box pair per step.
+ *
+ * @param {number[]|Float64Array} out length >= BOX_BOX_OUT_LENGTH
+ * @param {Float64Array} box_a
+ * @param {number} box_a_offset
+ * @param {Float64Array} box_b
+ * @param {number} box_b_offset
+ * @returns {boolean} true if overlap
+ */
+export function box_box_manifold_array(out, box_a, box_a_offset, box_b, box_b_offset) {
+    const ax = box_a[box_a_offset], ay = box_a[box_a_offset + 1], az = box_a[box_a_offset + 2];
+    const ahx = box_a[box_a_offset + 7], ahy = box_a[box_a_offset + 8], ahz = box_a[box_a_offset + 9];
+
+    const bx = box_b[box_b_offset], by = box_b[box_b_offset + 1], bz = box_b[box_b_offset + 2];
+    const bhx = box_b[box_b_offset + 7], bhy = box_b[box_b_offset + 8], bhz = box_b[box_b_offset + 9];
+
+    quat3_to_matrix3_array(scratch_axes_a, 0, box_a, box_a_offset + 3);
+    quat3_to_matrix3_array(scratch_axes_b, 0, box_b, box_b_offset + 3);
 
     const ta = scratch_axes_a;
     const tb = scratch_axes_b;
@@ -195,19 +249,21 @@ export function box_box_manifold(
 
     // Stage the per-pair inputs + reset the best-axis accumulator for the
     // hoisted test_axis (see the D3 note above it).
-    g_bb_ahx = ahx; g_bb_ahy = ahy; g_bb_ahz = ahz;
-    g_bb_bhx = bhx; g_bb_bhy = bhy; g_bb_bhz = bhz;
-    g_bb_dx = dx; g_bb_dy = dy; g_bb_dz = dz;
-    g_bb_best_overlap = Infinity;
-    g_bb_best_nx = 0; g_bb_best_ny = 0; g_bb_best_nz = 0;
+    bb[BB_A_HALF] = ahx; bb[BB_A_HALF + 1] = ahy; bb[BB_A_HALF + 2] = ahz;
+    bb[BB_B_HALF] = bhx; bb[BB_B_HALF + 1] = bhy; bb[BB_B_HALF + 2] = bhz;
+    bb[BB_D] = dx; bb[BB_D + 1] = dy; bb[BB_D + 2] = dz;
+    bb[BB_BEST_OVERLAP] = Infinity;
+    bb[BB_BEST_NORMAL] = 0; bb[BB_BEST_NORMAL + 1] = 0; bb[BB_BEST_NORMAL + 2] = 0;
     g_bb_best_source = -1;
 
-    if (test_axis(ta[0], ta[1], ta[2], 0)) return false;
-    if (test_axis(ta[3], ta[4], ta[5], 1)) return false;
-    if (test_axis(ta[6], ta[7], ta[8], 2)) return false;
-    if (test_axis(tb[0], tb[1], tb[2], 3)) return false;
-    if (test_axis(tb[3], tb[4], tb[5], 4)) return false;
-    if (test_axis(tb[6], tb[7], tb[8], 5)) return false;
+    if (test_axis(ta, 0, 0)) return false;
+    if (test_axis(ta, 3, 1)) return false;
+    if (test_axis(ta, 6, 2)) return false;
+    if (test_axis(tb, 0, 3)) return false;
+    if (test_axis(tb, 3, 4)) return false;
+    if (test_axis(tb, 6, 5)) return false;
+
+    const edge_axis = bb;
 
     for (let i = 0; i < 3; i++) {
         const i3 = i * 3;
@@ -217,18 +273,18 @@ export function box_box_manifold(
             const j3 = j * 3;
             const bjx = tb[j3], bjy = tb[j3 + 1], bjz = tb[j3 + 2];
 
-            const cx = aiy * bjz - aiz * bjy;
-            const cy = aiz * bjx - aix * bjz;
-            const cz = aix * bjy - aiy * bjx;
+            edge_axis[BB_EDGE_AXIS] = aiy * bjz - aiz * bjy;
+            edge_axis[BB_EDGE_AXIS + 1] = aiz * bjx - aix * bjz;
+            edge_axis[BB_EDGE_AXIS + 2] = aix * bjy - aiy * bjx;
 
-            if (test_axis(cx, cy, cz, 6 + i3 + j)) return false;
+            if (test_axis(edge_axis, BB_EDGE_AXIS, 6 + i3 + j)) return false;
         }
     }
 
     // We have a contact. Output the normal.
-    const best_overlap = g_bb_best_overlap;
+    const best_overlap = bb[BB_BEST_OVERLAP];
     const best_source = g_bb_best_source;
-    const nx = g_bb_best_nx, ny = g_bb_best_ny, nz = g_bb_best_nz;
+    const nx = bb[BB_BEST_NORMAL], ny = bb[BB_BEST_NORMAL + 1], nz = bb[BB_BEST_NORMAL + 2];
     out[0] = nx;
     out[1] = ny;
     out[2] = nz;