@woosh/meep-engine 3.37.0 → 3.39.0

package/src/core/geom/3d/gjk/gjk_epa_penetration.d.ts

@@ -40,11 +40,12 @@ export function gjk_epa_penetration(out: Float64Array | number[], A: SupportProv
  */
 export const GJK_SEPARATED: number;
 /**
- * A convex shape exposing a world-space support mapping: `support(out, off, dx,
- * dy, dz)` writes the farthest point of the shape in direction `(dx, dy, dz)`
- * into `out[off..off+2]` (e.g. {@link PosedShape3D }).
+ * A convex shape exposing a world-space support mapping: `support(out, off, direction,
+ * direction_offset)` writes the farthest point of the shape along the unit direction in
+ * `direction[direction_offset .. +2]` into `out[off..off+2]` (e.g. {@link PosedShape3D }), under the
+ * contract of {@link AbstractShape3Dsupport }.
  */
 export type SupportProvider = {
-    support: (arg0: Float64Array, arg1: number, arg2: number, arg3: number, arg4: number) => void;
+    support: (arg0: Float64Array, arg1: number, arg2: (Float64Array | number[]), arg3: number) => void;
 };
 //# sourceMappingURL=gjk_epa_penetration.d.ts.map

package/src/core/geom/3d/gjk/gjk_epa_penetration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AA6jBA;;;;;;;;;;;;;;;;GAgBG;AACH,yCATW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CA0BlB;AA7DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4BAFU,MAAM,CAEgB;;;;;;8BAzdnB;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}
+{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AAkkBA;;;;;;;;;;;;;;;;GAgBG;AACH,yCATW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CA0BlB;AA7DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4BAFU,MAAM,CAEgB;;;;;;;8BAzdnB;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,CAAC,YAAY,GAAC,MAAM,EAAE,CAAC,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}

package/src/core/geom/3d/gjk/gjk_epa_penetration.js

@@ -35,7 +35,7 @@ import { v3_triple_cross } from "../../vec3/v3_triple_cross.js";
  * Structure follows Bullet's btGjkEpa2: GJK produces a rank-4 simplex that
  * strictly encloses the origin; EPA builds outward-oriented faces from it and
  * expands toward the closest face, rebuilding the horizon each step. Operates on
- * any support provider with `support(out, off, dx, dy, dz)` in WORLD space (e.g.
+ * any support provider with `support(out, off, direction, direction_offset)` in WORLD space (e.g.
  * {@link PosedShape3D}); the penetration normal + depth come from the Minkowski
  * difference's closest face to the origin. No cross-frame state → reset-and-
  * resimulate determinism preserved.
@@ -74,6 +74,10 @@ const _w = new Float64Array(3); // newly sampled support point
 const SIMPLEX = new Float64Array(12); // 4 points, 3 floats each; slot 0 = newest (a)
 const DIR = new Float64Array(3);
 
+// GJK's seed directions, in arrays as minkowski_support takes them. Never written.
+const AXIS_X = new Float64Array([1, 0, 0]);
+const AXIS_Y = new Float64Array([0, 1, 0]);
+
 // --- vector scratch (shared; GJK and EPA never run concurrently) ---
 const _ab = new Float64Array(3);
 const _ac = new Float64Array(3);
@@ -92,11 +96,12 @@ const EDGE = new Int32Array(EDGE_CAP * 2); // horizon edges, 2 vertex indices ea
 const CEN = new Float64Array(3); // polytope centroid (for outward orientation)
 
 /**
- * A convex shape exposing a world-space support mapping: `support(out, off, dx,
- * dy, dz)` writes the farthest point of the shape in direction `(dx, dy, dz)`
- * into `out[off..off+2]` (e.g. {@link PosedShape3D}).
+ * A convex shape exposing a world-space support mapping: `support(out, off, direction,
+ * direction_offset)` writes the farthest point of the shape along the unit direction in
+ * `direction[direction_offset .. +2]` into `out[off..off+2]` (e.g. {@link PosedShape3D}), under the
+ * contract of {@link AbstractShape3D#support}.
  *
- * @typedef {{ support: function(Float64Array, number, number, number, number): void }} SupportProvider
+ * @typedef {{ support: function(Float64Array, number, (Float64Array|number[]), number): void }} SupportProvider
  */
 
 /**
@@ -140,9 +145,9 @@ const GJK_INCONCLUSIVE = 0;
  *   {@link GJK_INCONCLUSIVE}
  */
 function gjk(A, B) {
-    minkowski_support(SIMPLEX, 0, A, B, 1, 0, 0);
+    minkowski_support(SIMPLEX, 0, A, B, AXIS_X, 0);
     if (v3_length_sqr(SIMPLEX[0], SIMPLEX[1], SIMPLEX[2]) < DIR_EPS) {
-        minkowski_support(SIMPLEX, 0, A, B, 0, 1, 0);
+        minkowski_support(SIMPLEX, 0, A, B, AXIS_Y, 0);
     }
     DIR[0] = -SIMPLEX[0];
     DIR[1] = -SIMPLEX[1];
@@ -153,7 +158,7 @@ function gjk(A, B) {
         if (v3_length_sqr(DIR[0], DIR[1], DIR[2]) < DIR_EPS) {
             return GJK_INCONCLUSIVE; // direction collapsed → touching, or apart; unknown
         }
-        minkowski_support(_w, 0, A, B, DIR[0], DIR[1], DIR[2]);
+        minkowski_support(_w, 0, A, B, DIR, 0);
         if (v3_dot(_w[0], _w[1], _w[2], DIR[0], DIR[1], DIR[2]) < 0) {
             return GJK_APART; // farthest point short of the origin → proven separated
         }
@@ -478,7 +483,7 @@ function epa(A, B, out) {
         }
 
         const bn = best * 3;
-        minkowski_support(_w, 0, A, B, FACE_N[bn], FACE_N[bn + 1], FACE_N[bn + 2]);
+        minkowski_support(_w, 0, A, B, FACE_N, bn);
         const wdist = v3_dot(FACE_N[bn], FACE_N[bn + 1], FACE_N[bn + 2], _w[0], _w[1], _w[2]) - FACE_DIST[best];
         if (wdist < EPA_EPS) {
             break; // converged onto the closest face

package/src/core/geom/3d/gjk/minkowski_support.d.ts

@@ -17,17 +17,21 @@
  *
  * Shared by GJK, MPR, AND the robust penetration query
  * (`gjk_epa_penetration.js`): all three operate on the same support-provider
- * protocol — `support(out, off, dx, dy, dz)` with a unit direction — there
- * is no body-space/world-space split between them (a {@link PosedShape3D}
- * world adapter satisfies the same contract a raw shape does).
+ * protocol — `support(out, off, direction, direction_offset)` with a unit
+ * direction — there is no body-space/world-space split between them (a
+ * {@link PosedShape3D} world adapter satisfies the same contract a raw shape does).
+ *
+ * The direction arrives in an array, as it leaves for the two shapes: this is called from GJK, MPR
+ * and EPA loops that V8 does not always inline it into, and it calls two shapes' supports that V8
+ * never inlines, so a direction handed across as three numbers was boxed at both crossings.
  *
  * @param {Float64Array|number[]} result  3-vector destination
  * @param {number} result_offset
  * @param {AbstractShape3D} shape_a
  * @param {AbstractShape3D} shape_b
- * @param {number} dir_x  search direction (any non-zero magnitude)
- * @param {number} dir_y
- * @param {number} dir_z
+ * @param {Float64Array|number[]} direction search direction (any non-zero magnitude), at
+ *   `direction_offset`; read before anything is written, and left untouched
+ * @param {number} direction_offset
  */
-export function minkowski_support(result: Float64Array | number[], result_offset: number, shape_a: AbstractShape3D, shape_b: AbstractShape3D, dir_x: number, dir_y: number, dir_z: number): void;
+export function minkowski_support(result: Float64Array | number[], result_offset: number, shape_a: AbstractShape3D, shape_b: AbstractShape3D, direction: Float64Array | number[], direction_offset: number): void;
 //# sourceMappingURL=minkowski_support.d.ts.map

package/src/core/geom/3d/gjk/minkowski_support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"minkowski_support.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/minkowski_support.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,0CARW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,6DAGN,MAAM,SACN,MAAM,SACN,MAAM,QA2BhB"}
+{"version":3,"file":"minkowski_support.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/minkowski_support.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,0CARW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,iEAGN,YAAY,GAAC,MAAM,EAAE,oBAErB,MAAM,QAyChB"}

package/src/core/geom/3d/gjk/minkowski_support.js

@@ -19,24 +19,32 @@ import { v3_length } from "../../vec3/v3_length.js";
  *
  * Shared by GJK, MPR, AND the robust penetration query
  * (`gjk_epa_penetration.js`): all three operate on the same support-provider
- * protocol — `support(out, off, dx, dy, dz)` with a unit direction — there
- * is no body-space/world-space split between them (a {@link PosedShape3D}
- * world adapter satisfies the same contract a raw shape does).
+ * protocol — `support(out, off, direction, direction_offset)` with a unit
+ * direction — there is no body-space/world-space split between them (a
+ * {@link PosedShape3D} world adapter satisfies the same contract a raw shape does).
+ *
+ * The direction arrives in an array, as it leaves for the two shapes: this is called from GJK, MPR
+ * and EPA loops that V8 does not always inline it into, and it calls two shapes' supports that V8
+ * never inlines, so a direction handed across as three numbers was boxed at both crossings.
  *
  * @param {Float64Array|number[]} result  3-vector destination
  * @param {number} result_offset
  * @param {AbstractShape3D} shape_a
  * @param {AbstractShape3D} shape_b
- * @param {number} dir_x  search direction (any non-zero magnitude)
- * @param {number} dir_y
- * @param {number} dir_z
+ * @param {Float64Array|number[]} direction search direction (any non-zero magnitude), at
+ *   `direction_offset`; read before anything is written, and left untouched
+ * @param {number} direction_offset
  */
 export function minkowski_support(
     result, result_offset,
     shape_a,
     shape_b,
-    dir_x, dir_y, dir_z
+    direction, direction_offset
 ) {
+    let dir_x = direction[direction_offset];
+    let dir_y = direction[direction_offset + 1];
+    let dir_z = direction[direction_offset + 2];
+
     const len = v3_length(dir_x, dir_y, dir_z);
 
     if (len > 0) {
@@ -50,8 +58,18 @@ export function minkowski_support(
 
     }
 
-    shape_a.support(scratch_support_a, 0, dir_x, dir_y, dir_z);
-    shape_b.support(scratch_support_b, 0, -dir_x, -dir_y, -dir_z);
+    // One scratch for both directions, each written just before its call.
+    scratch_direction[0] = dir_x;
+    scratch_direction[1] = dir_y;
+    scratch_direction[2] = dir_z;
+
+    shape_a.support(scratch_support_a, 0, scratch_direction, 0);
+
+    scratch_direction[0] = -dir_x;
+    scratch_direction[1] = -dir_y;
+    scratch_direction[2] = -dir_z;
+
+    shape_b.support(scratch_support_b, 0, scratch_direction, 0);
 
     result[result_offset] = scratch_support_a[0] - scratch_support_b[0];
     result[result_offset + 1] = scratch_support_a[1] - scratch_support_b[1];
@@ -69,3 +87,9 @@ export function minkowski_support(
  */
 const scratch_support_a = new Float64Array(3);
 const scratch_support_b = new Float64Array(3);
+
+/**
+ * The unit direction handed to each shape's support, in double precision as the rest.
+ * @type {Float64Array}
+ */
+const scratch_direction = new Float64Array(3);

package/src/core/geom/3d/gjk/mpr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mpr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/mpr.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,4BANW,YAAY,iBACZ,MAAM,iDAGJ,OAAO,CA8TnB"}
+{"version":3,"file":"mpr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/mpr.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,4BANW,YAAY,iBACZ,MAAM,iDAGJ,OAAO,CA6UnB"}

package/src/core/geom/3d/gjk/mpr.js

@@ -52,6 +52,12 @@ const V2 = new Float64Array(3);
 const V3 = new Float64Array(3);
 const V4 = new Float64Array(3);
 
+/**
+ * The search direction handed to {@link minkowski_support}, which takes it in an array.
+ * @type {Float64Array}
+ */
+const search_direction = new Float64Array(3);
+
 /**
  * Minkowski Portal Refinement (XenoCollide, Gary Snethen, GDC 2009).
  *
@@ -146,7 +152,10 @@ export function mpr(result, result_offset, shape_a, shape_b) {
     }
 
     // ── Step 2: first support V1 in direction −V0 (toward the origin) ──
-    minkowski_support(V1, 0, shape_a, shape_b, -V0[0], -V0[1], -V0[2]);
+    search_direction[0] = -V0[0];
+    search_direction[1] = -V0[1];
+    search_direction[2] = -V0[2];
+    minkowski_support(V1, 0, shape_a, shape_b, search_direction, 0);
 
     // If V1 isn't past the origin along −V0, the origin lies outside
     // the Mink-diff and the shapes are separated.
@@ -184,7 +193,10 @@ export function mpr(result, result_offset, shape_a, shape_b) {
         return true;
     }
 
-    minkowski_support(V2, 0, shape_a, shape_b, nx, ny, nz);
+    search_direction[0] = nx;
+    search_direction[1] = ny;
+    search_direction[2] = nz;
+    minkowski_support(V2, 0, shape_a, shape_b, search_direction, 0);
 
     if (V2[0] * nx + V2[1] * ny + V2[2] * nz < 0) {
         return false;
@@ -212,7 +224,10 @@ export function mpr(result, result_offset, shape_a, shape_b) {
     // tetrahedron V0–V1–V2–V3 actually contains the origin.
     let discovered = false;
     for (let i = 0; i < MPR_MAX_ITERATIONS; i++) {
-        minkowski_support(V3, 0, shape_a, shape_b, nx, ny, nz);
+        search_direction[0] = nx;
+        search_direction[1] = ny;
+        search_direction[2] = nz;
+        minkowski_support(V3, 0, shape_a, shape_b, search_direction, 0);
 
         if (V3[0] * nx + V3[1] * ny + V3[2] * nz < 0) {
             return false;
@@ -317,7 +332,10 @@ export function mpr(result, result_offset, shape_a, shape_b) {
         const portal_dist = V1[0] * pn_x + V1[1] * pn_y + V1[2] * pn_z;
 
         // New support V4 in the portal normal direction.
-        minkowski_support(V4, 0, shape_a, shape_b, pn_x, pn_y, pn_z);
+        search_direction[0] = pn_x;
+        search_direction[1] = pn_y;
+        search_direction[2] = pn_z;
+        minkowski_support(V4, 0, shape_a, shape_b, search_direction, 0);
 
         const v4_dist = V4[0] * pn_x + V4[1] * pn_y + V4[2] * pn_z;
 
@@ -419,7 +437,10 @@ export function mpr(result, result_offset, shape_a, shape_b) {
     // separating-plane certificate costs one support call and holds
     // regardless of how the refinement terminated. Apply the same rule
     // both exits use rather than emitting an unexamined MTV.
-    minkowski_support(V4, 0, shape_a, shape_b, pn_x, pn_y, pn_z);
+    search_direction[0] = pn_x;
+    search_direction[1] = pn_y;
+    search_direction[2] = pn_z;
+    minkowski_support(V4, 0, shape_a, shape_b, search_direction, 0);
     if (V4[0] * pn_x + V4[1] * pn_y + V4[2] * pn_z < 0) {
         return false;
     }

package/src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.d.ts

@@ -41,4 +41,19 @@
  * @returns {number} t in [0, 1]
  */
 export function line3_compute_segment_closest_point_to_aabb3_t(p0_x: number, p0_y: number, p0_z: number, p1_x: number, p1_y: number, p1_z: number, box_x0: number, box_y0: number, box_z0: number, box_x1: number, box_y1: number, box_z1: number): number;
+/**
+ * {@link line3_compute_segment_closest_point_to_aabb3_t} with the segment read from
+ * `segment[segment_offset ..+5]` as `[p0, p1]` and the box from `box[box_offset ..+5]` as
+ * `[min, max]`, writing `t` to `result[result_offset]`. The one place the arithmetic lives. For a
+ * caller that cannot have the call inlined, where twelve numbers passed in and one returned would
+ * each be boxed into a new heap object.
+ *
+ * @param {Float64Array} result
+ * @param {number} result_offset
+ * @param {Float64Array} segment
+ * @param {number} segment_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ */
+export function line3_compute_segment_closest_point_to_aabb3_t_array(result: Float64Array, result_offset: number, segment: Float64Array, segment_offset: number, box: Float64Array, box_offset: number): void;
 //# sourceMappingURL=line3_compute_segment_closest_point_to_aabb3_t.d.ts.map

package/src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_closest_point_to_aabb3_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qEAdW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAqFlB"}
+{"version":3,"file":"line3_compute_segment_closest_point_to_aabb3_t.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qEAdW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CA0BlB;AAMD;;;;;;;;;;;;;GAaG;AACH,6EAPW,YAAY,iBACZ,MAAM,WACN,YAAY,kBACZ,MAAM,OACN,YAAY,cACZ,MAAM,QAsGhB"}

package/src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js

@@ -11,18 +11,30 @@ import { v3_dot } from "../../vec3/v3_dot.js";
  * narrowphase `g_ct_*` accumulators):
  *   a = (max t, g) with g' ≤ 0,  b = (min t, g) with g' > 0   → t_hi (rightmost min)
  *   c = (max t, g) with g' < 0,  d = (min t, g) with g' ≥ 0   → t_lo (leftmost min)
+ *
+ * In a Float64Array, `(t, g)` per tracker at A, B, C, D, rather than module-level `let`s: a number
+ * written to a module-level binding is boxed into a new heap object on every write. The candidate
+ * being folded in is staged there too, at CANDIDATE.
  */
-let _a_t = -1, _a_g = 0;
-let _b_t = 2, _b_g = 0;
-let _c_t = -1, _c_g = 0;
-let _d_t = 2, _d_g = 0;
-
-/** Fold one candidate `(t, g'(t))` into the argmin-interval trackers. */
-function _consider(t, g) {
-    if (g <= 0 && t > _a_t) { _a_t = t; _a_g = g; }
-    if (g > 0 && t < _b_t) { _b_t = t; _b_g = g; }
-    if (g < 0 && t > _c_t) { _c_t = t; _c_g = g; }
-    if (g >= 0 && t < _d_t) { _d_t = t; _d_g = g; }
+const TRACK_A = 0;
+const TRACK_B = 2;
+const TRACK_C = 4;
+const TRACK_D = 6;
+const TRACK_CANDIDATE = 8;
+const track = new Float64Array(10);
+
+/**
+ * Fold the staged candidate `(t, g'(t))` into the argmin-interval trackers. It is read from
+ * {@link track} rather than passed: the face-crossing candidates are folded in on a branch taken too
+ * rarely for V8 to inline the call, and a call that is not inlined boxes each number handed to it.
+ */
+function _consider() {
+    const t = track[TRACK_CANDIDATE], g = track[TRACK_CANDIDATE + 1];
+
+    if (g <= 0 && t > track[TRACK_A]) { track[TRACK_A] = t; track[TRACK_A + 1] = g; }
+    if (g > 0 && t < track[TRACK_B]) { track[TRACK_B] = t; track[TRACK_B + 1] = g; }
+    if (g < 0 && t > track[TRACK_C]) { track[TRACK_C] = t; track[TRACK_C + 1] = g; }
+    if (g >= 0 && t < track[TRACK_D]) { track[TRACK_D] = t; track[TRACK_D + 1] = g; }
 }
 
 /**
@@ -73,33 +85,86 @@ export function line3_compute_segment_closest_point_to_aabb3_t(
     box_x0, box_y0, box_z0,
     box_x1, box_y1, box_z1
 ) {
+    const inputs = scalar_inputs;
+
+    inputs[0] = p0_x;
+    inputs[1] = p0_y;
+    inputs[2] = p0_z;
+    inputs[3] = p1_x;
+    inputs[4] = p1_y;
+    inputs[5] = p1_z;
+    inputs[6] = box_x0;
+    inputs[7] = box_y0;
+    inputs[8] = box_z0;
+    inputs[9] = box_x1;
+    inputs[10] = box_y1;
+    inputs[11] = box_z1;
+
+    line3_compute_segment_closest_point_to_aabb3_t_array(scalar_result, 0, inputs, 0, inputs, 6);
+
+    return scalar_result[0];
+}
+
+/** Where {@link line3_compute_segment_closest_point_to_aabb3_t} packs its segment and its box. */
+const scalar_inputs = new Float64Array(12);
+const scalar_result = new Float64Array(1);
+
+/**
+ * {@link line3_compute_segment_closest_point_to_aabb3_t} with the segment read from
+ * `segment[segment_offset ..+5]` as `[p0, p1]` and the box from `box[box_offset ..+5]` as
+ * `[min, max]`, writing `t` to `result[result_offset]`. The one place the arithmetic lives. For a
+ * caller that cannot have the call inlined, where twelve numbers passed in and one returned would
+ * each be boxed into a new heap object.
+ *
+ * @param {Float64Array} result
+ * @param {number} result_offset
+ * @param {Float64Array} segment
+ * @param {number} segment_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ */
+export function line3_compute_segment_closest_point_to_aabb3_t_array(
+    result, result_offset,
+    segment, segment_offset,
+    box, box_offset
+) {
+    const p0_x = segment[segment_offset], p0_y = segment[segment_offset + 1], p0_z = segment[segment_offset + 2];
+    const p1_x = segment[segment_offset + 3], p1_y = segment[segment_offset + 4], p1_z = segment[segment_offset + 5];
+    const box_x0 = box[box_offset], box_y0 = box[box_offset + 1], box_z0 = box[box_offset + 2];
+    const box_x1 = box[box_offset + 3], box_y1 = box[box_offset + 4], box_z1 = box[box_offset + 5];
+
     const d_x = p1_x - p0_x;
     const d_y = p1_y - p0_y;
     const d_z = p1_z - p0_z;
 
     if (d_x === 0 && d_y === 0 && d_z === 0) {
         // Degenerate segment (a point) — its parameter is arbitrary.
-        return 0;
+        result[result_offset] = 0;
+        return;
     }
 
-    _a_t = -1; _a_g = 0;
-    _b_t = 2; _b_g = 0;
-    _c_t = -1; _c_g = 0;
-    _d_t = 2; _d_g = 0;
+    track[TRACK_A] = -1; track[TRACK_A + 1] = 0;
+    track[TRACK_B] = 2; track[TRACK_B + 1] = 0;
+    track[TRACK_C] = -1; track[TRACK_C + 1] = 0;
+    track[TRACK_D] = 2; track[TRACK_D + 1] = 0;
 
     // Endpoint candidates.
-    _consider(0, v3_dot(
+    track[TRACK_CANDIDATE] = 0;
+    track[TRACK_CANDIDATE + 1] = v3_dot(
         p0_x - clamp(p0_x, box_x0, box_x1),
         p0_y - clamp(p0_y, box_y0, box_y1),
         p0_z - clamp(p0_z, box_z0, box_z1),
         d_x, d_y, d_z
-    ));
-    _consider(1, v3_dot(
+    );
+    _consider();
+    track[TRACK_CANDIDATE] = 1;
+    track[TRACK_CANDIDATE + 1] = v3_dot(
         p1_x - clamp(p1_x, box_x0, box_x1),
         p1_y - clamp(p1_y, box_y0, box_y1),
         p1_z - clamp(p1_z, box_z0, box_z1),
         d_x, d_y, d_z
-    ));
+    );
+    _consider();
 
     // Face-plane crossing candidates (where an axis enters/leaves its slab).
     for (let axis = 0; axis < 3; axis++) {
@@ -120,34 +185,42 @@ export function line3_compute_segment_closest_point_to_aabb3_t(
             const c_x = p0_x + d_x * tc;
             const c_y = p0_y + d_y * tc;
             const c_z = p0_z + d_z * tc;
-            _consider(tc, v3_dot(
-                c_x - clamp(c_x, box_x0, box_x1),
-                c_y - clamp(c_y, box_y0, box_y1),
-                c_z - clamp(c_z, box_z0, box_z1),
-                d_x, d_y, d_z
-            ));
+            // v3_dot of the offset from the clamped point, written out with clamp's comparisons:
+            // this branch is taken too rarely for V8 to inline calls on it, and they box what
+            // they are handed
+            const k_x = c_x < box_x0 ? box_x0 : (c_x > box_x1 ? box_x1 : c_x);
+            const k_y = c_y < box_y0 ? box_y0 : (c_y > box_y1 ? box_y1 : c_y);
+            const k_z = c_z < box_z0 ? box_z0 : (c_z > box_z1 ? box_z1 : c_z);
+            track[TRACK_CANDIDATE] = tc;
+            track[TRACK_CANDIDATE + 1] = ((c_x - k_x) * d_x + (c_y - k_y) * d_y + (c_z - k_z) * d_z);
+            _consider();
         }
     }
 
+    const a_t = track[TRACK_A], a_g = track[TRACK_A + 1];
+    const b_t = track[TRACK_B], b_g = track[TRACK_B + 1];
+    const c_t = track[TRACK_C], c_g = track[TRACK_C + 1];
+    const d_t = track[TRACK_D], d_g = track[TRACK_D + 1];
+
     // Rightmost minimiser: where g' last reaches 0 (g' linear between a and b).
     let t_hi;
-    if (_a_t < 0) {
+    if (a_t < 0) {
         t_hi = 0;          // g' > 0 everywhere → minimum at the p0 end
-    } else if (_b_t > 1) {
+    } else if (b_t > 1) {
         t_hi = 1;          // g' ≤ 0 everywhere → minimum at the p1 end
     } else {
-        t_hi = _a_t - _a_g * (_b_t - _a_t) / (_b_g - _a_g);
+        t_hi = a_t - a_g * (b_t - a_t) / (b_g - a_g);
     }
 
     // Leftmost minimiser: where g' first reaches 0.
     let t_lo;
-    if (_d_t > 1) {
+    if (d_t > 1) {
         t_lo = 1;          // g' < 0 everywhere → minimum at the p1 end
-    } else if (_c_t < 0) {
+    } else if (c_t < 0) {
         t_lo = 0;          // g' ≥ 0 everywhere → minimum at the p0 end
     } else {
-        t_lo = _c_t - _c_g * (_d_t - _c_t) / (_d_g - _c_g);
+        t_lo = c_t - c_g * (d_t - c_t) / (d_g - c_g);
     }
 
-    return (t_lo + t_hi) * 0.5;
+    result[result_offset] = (t_lo + t_hi) * 0.5;
 }

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.d.ts

@@ -7,7 +7,8 @@
  * gl-matrix `mat4.fromRotationTranslationScale`. The quaternion is assumed to be of
  * unit length. Allocation-free.
  *
- * Both flavours share {@link m4_from_rotation_translation_scale_scalar}.
+ * {@link m4_from_rotation_translation_scale_array} with every offset 0, which is where the
+ * arithmetic lives; use that one for operands at other offsets.
  *
  * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
  * @param {number[]|Float32Array|Float64Array} q rotation quaternion `[x, y, z, w]`

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_from_rotation_translation_scale.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wDATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAc9C"}
+{"version":3,"file":"m4_from_rotation_translation_scale.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wDATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAS9C"}

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js

@@ -1,4 +1,4 @@
-import { m4_from_rotation_translation_scale_scalar } from "./m4_from_rotation_translation_scale_scalar.js";
+import { m4_from_rotation_translation_scale_array } from "./m4_from_rotation_translation_scale_array.js";
 
 /**
  * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a
@@ -9,7 +9,8 @@ import { m4_from_rotation_translation_scale_scalar } from "./m4_from_rotation_tr
  * gl-matrix `mat4.fromRotationTranslationScale`. The quaternion is assumed to be of
  * unit length. Allocation-free.
  *
- * Both flavours share {@link m4_from_rotation_translation_scale_scalar}.
+ * {@link m4_from_rotation_translation_scale_array} with every offset 0, which is where the
+ * arithmetic lives; use that one for operands at other offsets.
  *
  * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
  * @param {number[]|Float32Array|Float64Array} q rotation quaternion `[x, y, z, w]`
@@ -21,12 +22,7 @@ import { m4_from_rotation_translation_scale_scalar } from "./m4_from_rotation_tr
  * @copyright Company Named Limited (c) 2026
  */
 export function m4_from_rotation_translation_scale(out, q, v, s) {
-    m4_from_rotation_translation_scale_scalar(
-        out,
-        q[0], q[1], q[2], q[3],
-        v[0], v[1], v[2],
-        s[0], s[1], s[2]
-    );
+    m4_from_rotation_translation_scale_array(out, q, 0, v, 0, s, 0);
 
     return out;
 }

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_array.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a (non-uniform) scale,
+ * each read from an array at an offset. `out = T * R * S`.
+ *
+ * The one place the quaternion→matrix expansion lives: {@link m4_from_rotation_translation_scale}
+ * (arrays at offset 0) hands it its arrays, and {@link m4_from_rotation_translation_scale_scalar}
+ * packs its numbers for it. Use this one wherever the operands already sit in flat arrays, such as
+ * {@link Transform64}, which packs the matrix and all three operands in a single buffer: a caller V8
+ * does not inline this into passes arrays and small integers, where handing over the ten operands as
+ * numbers would box each of them into a new heap object.
+ *
+ * Inverse of {@link m4_decompose_array}, and shaped like it: the matrix at offset 0, each operand at
+ * its own offset.
+ *
+ * Every operand is read before the first element of `out` is written, so the operands may overlap
+ * `out`, as a {@link Transform64}'s translation overlaps its matrix.
+ *
+ * The quaternion is assumed to be of unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix, column-major
+ * @param {number[]|Float32Array|Float64Array} rotation quaternion `[x, y, z, w]`
+ * @param {number} rotation_offset offset into `rotation`
+ * @param {number[]|Float32Array|Float64Array} translation `[x, y, z]`
+ * @param {number} translation_offset offset into `translation`
+ * @param {number[]|Float32Array|Float64Array} scale `[x, y, z]`
+ * @param {number} scale_offset offset into `scale`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale_array(out: number[] | Float32Array | Float64Array, rotation: number[] | Float32Array | Float64Array, rotation_offset: number, translation: number[] | Float32Array | Float64Array, translation_offset: number, scale: number[] | Float32Array | Float64Array, scale_offset: number): void;
+//# sourceMappingURL=m4_from_rotation_translation_scale_array.d.ts.map

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_from_rotation_translation_scale_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale_array.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8DAXW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,QA2DhB"}