@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -15,6 +15,14 @@
  * @param {number} half_height
  */
 export function capsule_world_segment(out: number[] | Float64Array, cx: number, cy: number, cz: number, qx: number, qy: number, qz: number, qw: number, half_height: number): void;
+/**
+ * {@link capsule_world_segment} with the capsule read from a record (its radius is not read).
+ *
+ * @param {number[]|Float64Array} out length >= 6
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ */
+export function capsule_world_segment_array(out: number[] | Float64Array, capsule: Float64Array, capsule_offset: number): void;
 /**
  * Capsule (A) vs sphere (B) contact, closed-form via point-segment distance.
  *
@@ -35,6 +43,17 @@ export function capsule_world_segment(out: number[] | Float64Array, cx: number,
  * @returns {boolean} true on overlap
  */
 export function capsule_sphere_contact(out: number[] | Float64Array, a_cx: number, a_cy: number, a_cz: number, a_qx: number, a_qy: number, a_qz: number, a_qw: number, a_radius: number, a_half_h: number, b_cx: number, b_cy: number, b_cz: number, b_radius: number): boolean;
+/**
+ * {@link capsule_sphere_contact} with the capsule (A) and the sphere (B) read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ * @param {Float64Array} sphere
+ * @param {number} sphere_offset
+ * @returns {boolean} true on overlap
+ */
+export function capsule_sphere_contact_array(out: number[] | Float64Array, capsule: Float64Array, capsule_offset: number, sphere: Float64Array, sphere_offset: number): boolean;
 /**
  * Two capsules (A and B). Reduces to segment-segment closest pair + radius.
  *
@@ -42,6 +61,17 @@ export function capsule_sphere_contact(out: number[] | Float64Array, a_cx: numbe
  * @returns {boolean} true on overlap
  */
 export function capsule_capsule_contact(out: number[] | Float64Array, a_cx: any, a_cy: any, a_cz: any, a_qx: any, a_qy: any, a_qz: any, a_qw: any, a_radius: any, a_half_h: any, b_cx: any, b_cy: any, b_cz: any, b_qx: any, b_qy: any, b_qz: any, b_qw: any, b_radius: any, b_half_h: any): boolean;
+/**
+ * {@link capsule_capsule_contact} with both capsules read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} capsule_a
+ * @param {number} capsule_a_offset
+ * @param {Float64Array} capsule_b
+ * @param {number} capsule_b_offset
+ * @returns {boolean} true on overlap
+ */
+export function capsule_capsule_contact_array(out: number[] | Float64Array, capsule_a: Float64Array, capsule_a_offset: number, capsule_b: Float64Array, capsule_b_offset: number): boolean;
 /**
  * Capsule-vs-capsule with a parallel-aware multi-point manifold: NEAR-PARALLEL
  * overlapping capsules emit one contact at each end of their axial overlap
@@ -53,6 +83,17 @@ export function capsule_capsule_contact(out: number[] | Float64Array, a_cx: any,
  * @returns {number} number of contacts written (0 = no overlap)
  */
 export function capsule_capsule_multi_contacts(out: number[] | Float64Array, a_cx: any, a_cy: any, a_cz: any, a_qx: any, a_qy: any, a_qz: any, a_qw: any, a_radius: any, a_half_h: any, b_cx: any, b_cy: any, b_cz: any, b_qx: any, b_qy: any, b_qz: any, b_qw: any, b_radius: any, b_half_h: any): number;
+/**
+ * {@link capsule_capsule_multi_contacts} with both capsules read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 2 * CAPSULE_CAPSULE_CONTACT_STRIDE
+ * @param {Float64Array} capsule_a
+ * @param {number} capsule_a_offset
+ * @param {Float64Array} capsule_b
+ * @param {number} capsule_b_offset
+ * @returns {number} number of contacts written (0 = no overlap)
+ */
+export function capsule_capsule_multi_contacts_array(out: number[] | Float64Array, capsule_a: Float64Array, capsule_a_offset: number, capsule_b: Float64Array, capsule_b_offset: number): number;
 /**
  * Capsule (A) vs oriented box (B). Brings the capsule segment into box-local
  * space, then refines via 2 fixed-point iterations between:
@@ -68,6 +109,17 @@ export function capsule_capsule_multi_contacts(out: number[] | Float64Array, a_c
  * @returns {boolean}
  */
 export function capsule_box_contact(out: number[] | Float64Array, a_cx: any, a_cy: any, a_cz: any, a_qx: any, a_qy: any, a_qz: any, a_qw: any, a_radius: any, a_half_h: any, b_cx: any, b_cy: any, b_cz: any, b_qx: any, b_qy: any, b_qz: any, b_qw: any, b_hx: any, b_hy: any, b_hz: any): boolean;
+/**
+ * {@link capsule_box_contact} with the capsule (A) and the box (B) read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ * @returns {boolean}
+ */
+export function capsule_box_contact_array(out: number[] | Float64Array, capsule: Float64Array, capsule_offset: number, box: Float64Array, box_offset: number): boolean;
 /**
  * Multi-point capsule-vs-OBB contact generation. Emits up to
  * {@link CAPSULE_BOX_MAX_CONTACTS} contacts into `out` in the
@@ -111,6 +163,17 @@ export function capsule_box_contact(out: number[] | Float64Array, a_cx: any, a_c
  * @returns {number} number of contacts emitted, in `[0, CAPSULE_BOX_MAX_CONTACTS]`
  */
 export function capsule_box_multi_contacts(out: Float64Array, a_cx: number, a_cy: number, a_cz: number, a_qx: number, a_qy: number, a_qz: number, a_qw: number, a_radius: number, a_half_h: number, b_cx: number, b_cy: number, b_cz: number, b_qx: number, b_qy: number, b_qz: number, b_qw: number, b_hx: number, b_hy: number, b_hz: number): number;
+/**
+ * {@link capsule_box_multi_contacts} with the capsule (A) and the box (B) read from records.
+ *
+ * @param {Float64Array} out length >= CAPSULE_BOX_MAX_CONTACTS * CAPSULE_BOX_CONTACT_STRIDE
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ * @returns {number} number of contacts emitted, in `[0, CAPSULE_BOX_MAX_CONTACTS]`
+ */
+export function capsule_box_multi_contacts_array(out: Float64Array, capsule: Float64Array, capsule_offset: number, box: Float64Array, box_offset: number): number;
 /**
  * Output stride per contact in {@link capsule_capsule_multi_contacts} —
  * matches {@link CAPSULE_BOX_CONTACT_STRIDE}:

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

@@ -1 +1 @@
-{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAOhB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAoEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAyHlB;AASD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CA6FnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAsElB;AAtaD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AAmQ9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}
+{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAMhB;AAED;;;;;;GAMG;AACH,iDAJW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,QAehB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CAYnB;AAED;;;;;;;;;GASG;AACH,kDAPW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAYnB;AAED;;;;;;;;;GASG;AACH,mDAPW,MAAM,EAAE,GAAC,YAAY,aACrB,YAAY,oBACZ,MAAM,aACN,YAAY,oBACZ,MAAM,GACJ,OAAO,CAmEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAYlB;AAED;;;;;;;;;GASG;AACH,0DAPW,MAAM,EAAE,GAAC,YAAY,aACrB,YAAY,oBACZ,MAAM,aACN,YAAY,oBACZ,MAAM,GACJ,MAAM,CAsHlB;AAeD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CAYnB;AAsBD;;;;;;;;;GASG;AACH,+CAPW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CAoGnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAYlB;AAKD;;;;;;;;;GASG;AACH,sDAPW,YAAY,WACZ,YAAY,kBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA4DlB;AA/fD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AA6U9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}

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

@@ -2,10 +2,10 @@ import { line3_segment_segment_closest_point_pair } from "../../../core/geom/3d/
 const scratch_pair = new Float64Array(6);
 import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
 import { line3_compute_segment_closest_point_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
-import { line3_compute_segment_closest_point_to_aabb3_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js";
-import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
-import { v3_quaternion_apply_inverse } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
-import { sphere_box_contact } from "./sphere_box_contact.js";
+import { line3_compute_segment_closest_point_to_aabb3_t_array } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js";
+import { v3_quaternion_apply_array } from "../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_quaternion_apply_inverse_array } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { sphere_box_contact_array } from "./sphere_box_contact.js";
 
 /**
  * Closed-form narrowphase helpers for the capsule family. A capsule is the
@@ -21,6 +21,13 @@ import { sphere_box_contact } from "./sphere_box_contact.js";
  *   out[4..6] : world contact on A's surface
  *   out[7..9] : world contact on B's surface
  *
+ * Every routine has an `_array` form that reads its bodies from records — a capsule as `[centre (3),
+ * orientation (unit quaternion, 4), radius, half-height]`, nine numbers; a sphere as `[centre (3),
+ * radius]`; a box as `[centre (3), orientation (4), half-extents (3)]` — and the scalar forms pack
+ * their numbers for it. A call V8 does not inline boxes each number passed to it, up to nineteen per
+ * call here, once per pair per step, so the narrowphase calls the array forms, and they call each
+ * other and the rotations the same way.
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -29,6 +36,34 @@ const scratch_st = new Float64Array(2);
 
 const scratch_seg = new Float64Array(6);
 
+/** Where the scalar forms pack their bodies. */
+const scratch_capsule_a = new Float64Array(9);
+const scratch_capsule_b = new Float64Array(9);
+const scratch_sphere_b = new Float64Array(4);
+const scratch_box_b = new Float64Array(10);
+
+/** A body-local vector rotated to world through {@link v3_quaternion_apply_array}. */
+const scratch_vector = new Float64Array(3);
+
+/**
+ * Pack a capsule record.
+ * @param {Float64Array} out
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} radius
+ * @param {number} half_height
+ */
+function capsule_pack(out, cx, cy, cz, qx, qy, qz, qw, radius, half_height) {
+    out[0] = cx; out[1] = cy; out[2] = cz;
+    out[3] = qx; out[4] = qy; out[5] = qz; out[6] = qw;
+    out[7] = radius; out[8] = half_height;
+}
+
 /**
  * Compute the two world endpoints of a capsule's central segment given its
  * pose. The capsule is Y-aligned in body frame; the segment runs from
@@ -46,8 +81,29 @@ const scratch_seg = new Float64Array(6);
  * @param {number} half_height
  */
 export function capsule_world_segment(out, cx, cy, cz, qx, qy, qz, qw, half_height) {
-    v3_quaternion_apply(out, 0, 0, -half_height, 0, qx, qy, qz, qw);
-    v3_quaternion_apply(out, 3, 0,  half_height, 0, qx, qy, qz, qw);
+    const capsule = scratch_capsule_a;
+    capsule_pack(capsule, cx, cy, cz, qx, qy, qz, qw, 0, half_height);
+    capsule_world_segment_array(out, capsule, 0);
+}
+
+/**
+ * {@link capsule_world_segment} with the capsule read from a record (its radius is not read).
+ *
+ * @param {number[]|Float64Array} out length >= 6
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ */
+export function capsule_world_segment_array(out, capsule, capsule_offset) {
+    const half_height = capsule[capsule_offset + 8];
+    const rotation = capsule_offset + 3;
+    const v = scratch_vector;
+
+    v[0] = 0; v[1] = -half_height; v[2] = 0;
+    v3_quaternion_apply_array(out, 0, v, 0, capsule, rotation);
+    v[1] = half_height;
+    v3_quaternion_apply_array(out, 3, v, 0, capsule, rotation);
+
+    const cx = capsule[capsule_offset], cy = capsule[capsule_offset + 1], cz = capsule[capsule_offset + 2];
     out[0] += cx; out[1] += cy; out[2] += cz;
     out[3] += cx; out[4] += cy; out[5] += cz;
 }
@@ -78,7 +134,29 @@ export function capsule_sphere_contact(
     a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h,
     b_cx, b_cy, b_cz, b_radius
 ) {
-    capsule_world_segment(scratch_seg, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_half_h);
+    const capsule = scratch_capsule_a;
+    const sphere = scratch_sphere_b;
+    capsule_pack(capsule, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h);
+    sphere[0] = b_cx; sphere[1] = b_cy; sphere[2] = b_cz; sphere[3] = b_radius;
+    return capsule_sphere_contact_array(out, capsule, 0, sphere, 0);
+}
+
+/**
+ * {@link capsule_sphere_contact} with the capsule (A) and the sphere (B) read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ * @param {Float64Array} sphere
+ * @param {number} sphere_offset
+ * @returns {boolean} true on overlap
+ */
+export function capsule_sphere_contact_array(out, capsule, capsule_offset, sphere, sphere_offset) {
+    const a_radius = capsule[capsule_offset + 7];
+    const b_cx = sphere[sphere_offset], b_cy = sphere[sphere_offset + 1], b_cz = sphere[sphere_offset + 2];
+    const b_radius = sphere[sphere_offset + 3];
+
+    capsule_world_segment_array(scratch_seg, capsule, capsule_offset);
     const sax = scratch_seg[0], say = scratch_seg[1], saz = scratch_seg[2];
     const sbx = scratch_seg[3], sby = scratch_seg[4], sbz = scratch_seg[5];
 
@@ -133,8 +211,29 @@ export function capsule_capsule_contact(
     a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h,
     b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_radius, b_half_h
 ) {
-    capsule_world_segment(scratch_seg,   a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_half_h);
-    capsule_world_segment(scratch_seg_b, b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_half_h);
+    const capsule_a = scratch_capsule_a;
+    const capsule_b = scratch_capsule_b;
+    capsule_pack(capsule_a, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h);
+    capsule_pack(capsule_b, b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_radius, b_half_h);
+    return capsule_capsule_contact_array(out, capsule_a, 0, capsule_b, 0);
+}
+
+/**
+ * {@link capsule_capsule_contact} with both capsules read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} capsule_a
+ * @param {number} capsule_a_offset
+ * @param {Float64Array} capsule_b
+ * @param {number} capsule_b_offset
+ * @returns {boolean} true on overlap
+ */
+export function capsule_capsule_contact_array(out, capsule_a, capsule_a_offset, capsule_b, capsule_b_offset) {
+    const a_radius = capsule_a[capsule_a_offset + 7];
+    const b_radius = capsule_b[capsule_b_offset + 7];
+
+    capsule_world_segment_array(scratch_seg, capsule_a, capsule_a_offset);
+    capsule_world_segment_array(scratch_seg_b, capsule_b, capsule_b_offset);
 
     const a0x = scratch_seg[0], a0y = scratch_seg[1], a0z = scratch_seg[2];
     const a1x = scratch_seg[3], a1y = scratch_seg[4], a1z = scratch_seg[5];
@@ -239,8 +338,31 @@ export function capsule_capsule_multi_contacts(
     a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h,
     b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_radius, b_half_h
 ) {
-    capsule_world_segment(scratch_seg,   a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_half_h);
-    capsule_world_segment(scratch_seg_b, b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_half_h);
+    const capsule_a = scratch_capsule_a;
+    const capsule_b = scratch_capsule_b;
+    capsule_pack(capsule_a, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h);
+    capsule_pack(capsule_b, b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_radius, b_half_h);
+    return capsule_capsule_multi_contacts_array(out, capsule_a, 0, capsule_b, 0);
+}
+
+/**
+ * {@link capsule_capsule_multi_contacts} with both capsules read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 2 * CAPSULE_CAPSULE_CONTACT_STRIDE
+ * @param {Float64Array} capsule_a
+ * @param {number} capsule_a_offset
+ * @param {Float64Array} capsule_b
+ * @param {number} capsule_b_offset
+ * @returns {number} number of contacts written (0 = no overlap)
+ */
+export function capsule_capsule_multi_contacts_array(out, capsule_a, capsule_a_offset, capsule_b, capsule_b_offset) {
+    const a_cx = capsule_a[capsule_a_offset], a_cy = capsule_a[capsule_a_offset + 1], a_cz = capsule_a[capsule_a_offset + 2];
+    const a_radius = capsule_a[capsule_a_offset + 7];
+    const b_cx = capsule_b[capsule_b_offset], b_cy = capsule_b[capsule_b_offset + 1], b_cz = capsule_b[capsule_b_offset + 2];
+    const b_radius = capsule_b[capsule_b_offset + 7];
+
+    capsule_world_segment_array(scratch_seg, capsule_a, capsule_a_offset);
+    capsule_world_segment_array(scratch_seg_b, capsule_b, capsule_b_offset);
 
     const a0x = scratch_seg[0], a0y = scratch_seg[1], a0z = scratch_seg[2];
     const a1x = scratch_seg[3], a1y = scratch_seg[4], a1z = scratch_seg[5];
@@ -335,11 +457,7 @@ export function capsule_capsule_multi_contacts(
     }
 
     // General case: single closest-point contact.
-    if (!capsule_capsule_contact(
-        scratch_single,
-        a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h,
-        b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_radius, b_half_h
-    )) {
+    if (!capsule_capsule_contact_array(scratch_single, capsule_a, capsule_a_offset, capsule_b, capsule_b_offset)) {
         return 0;
     }
     out[0] = scratch_single[4];
@@ -359,8 +477,14 @@ const scratch_single = new Float64Array(10);
 
 // --- capsule vs oriented box ------------------------------------------------
 
-const scratch_a0_local = new Float64Array(3);
-const scratch_a1_local = new Float64Array(3);
+/** The capsule's segment in the box's frame, both endpoints. */
+const scratch_seg_local = new Float64Array(6);
+
+/** The box-local box, `[−h, h]`, for the segment-vs-box query. */
+const scratch_aabb = new Float64Array(6);
+
+/** The segment parameter of the closest point to the box. */
+const scratch_t = new Float64Array(1);
 
 /**
  * Capsule (A) vs oriented box (B). Brings the capsule segment into box-local
@@ -381,18 +505,62 @@ export function capsule_box_contact(
     a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h,
     b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_hx, b_hy, b_hz
 ) {
+    const capsule = scratch_capsule_a;
+    const box = scratch_box_b;
+    capsule_pack(capsule, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h);
+    box_pack(box, b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_hx, b_hy, b_hz);
+    return capsule_box_contact_array(out, capsule, 0, box, 0);
+}
+
+/**
+ * Pack a box record.
+ * @param {Float64Array} out
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} hx
+ * @param {number} hy
+ * @param {number} hz
+ */
+function box_pack(out, cx, cy, cz, qx, qy, qz, qw, hx, hy, hz) {
+    out[0] = cx; out[1] = cy; out[2] = cz;
+    out[3] = qx; out[4] = qy; out[5] = qz; out[6] = qw;
+    out[7] = hx; out[8] = hy; out[9] = hz;
+}
+
+/**
+ * {@link capsule_box_contact} with the capsule (A) and the box (B) read from records.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ * @returns {boolean}
+ */
+export function capsule_box_contact_array(out, capsule, capsule_offset, box, box_offset) {
+    const a_radius = capsule[capsule_offset + 7];
+    const b_cx = box[box_offset], b_cy = box[box_offset + 1], b_cz = box[box_offset + 2];
+    const b_hx = box[box_offset + 7], b_hy = box[box_offset + 8], b_hz = box[box_offset + 9];
+    const rotation = box_offset + 3;
+
     // Bring the capsule's segment endpoints into box-local space: build them in
     // world first (from the capsule centre + rotated half-height axis), then map
     // world → box-local below.
-    capsule_world_segment(scratch_seg, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_half_h);
+    capsule_world_segment_array(scratch_seg, capsule, capsule_offset);
     // World → box-local: subtract box centre, then rotate by conjugate of box quat.
-    const w_a0x = scratch_seg[0] - b_cx, w_a0y = scratch_seg[1] - b_cy, w_a0z = scratch_seg[2] - b_cz;
-    const w_a1x = scratch_seg[3] - b_cx, w_a1y = scratch_seg[4] - b_cy, w_a1z = scratch_seg[5] - b_cz;
-    v3_quaternion_apply_inverse(scratch_a0_local, 0, w_a0x, w_a0y, w_a0z, b_qx, b_qy, b_qz, b_qw);
-    v3_quaternion_apply_inverse(scratch_a1_local, 0, w_a1x, w_a1y, w_a1z, b_qx, b_qy, b_qz, b_qw);
+    const local = scratch_seg_local;
+    local[0] = scratch_seg[0] - b_cx; local[1] = scratch_seg[1] - b_cy; local[2] = scratch_seg[2] - b_cz;
+    local[3] = scratch_seg[3] - b_cx; local[4] = scratch_seg[4] - b_cy; local[5] = scratch_seg[5] - b_cz;
+    v3_quaternion_apply_inverse_array(local, 0, local, 0, box, rotation);
+    v3_quaternion_apply_inverse_array(local, 3, local, 3, box, rotation);
 
-    const a0lx = scratch_a0_local[0], a0ly = scratch_a0_local[1], a0lz = scratch_a0_local[2];
-    const a1lx = scratch_a1_local[0], a1ly = scratch_a1_local[1], a1lz = scratch_a1_local[2];
+    const a0lx = local[0], a0ly = local[1], a0lz = local[2];
+    const a1lx = local[3], a1ly = local[4], a1lz = local[5];
 
     // Exact closest point on the capsule segment to the box-local AABB [−h, h].
     // Replaces a 2-iteration alternating projection (project onto segment, clamp
@@ -400,10 +568,11 @@ export function capsule_box_contact(
     // a box face/edge — overestimating the segment-vs-box distance, which
     // under-detected contacts (~0.85% of random configs missed) and mis-placed
     // depth/normal on many more. See core/geom/3d/gjk/GJK_REVIEW_NOTES.md.
-    const t = line3_compute_segment_closest_point_to_aabb3_t(
-        a0lx, a0ly, a0lz, a1lx, a1ly, a1lz,
-        -b_hx, -b_hy, -b_hz, b_hx, b_hy, b_hz
-    );
+    const aabb = scratch_aabb;
+    aabb[0] = -b_hx; aabb[1] = -b_hy; aabb[2] = -b_hz;
+    aabb[3] = b_hx; aabb[4] = b_hy; aabb[5] = b_hz;
+    line3_compute_segment_closest_point_to_aabb3_t_array(scratch_t, 0, local, 0, aabb, 0);
+    const t = scratch_t[0];
     const plx = a0lx + (a1lx - a0lx) * t;
     const ply = a0ly + (a1ly - a0ly) * t;
     const plz = a0lz + (a1lz - a0lz) * t;
@@ -450,18 +619,22 @@ export function capsule_box_contact(
     }
 
     // Normal (box → capsule axis point) into world.
-    v3_quaternion_apply(out, 0, nlx, nly, nlz, b_qx, b_qy, b_qz, b_qw);
+    const v = scratch_vector;
+    v[0] = nlx; v[1] = nly; v[2] = nlz;
+    v3_quaternion_apply_array(out, 0, v, 0, box, rotation);
     const nx = out[0], ny = out[1], nz = out[2];
     out[3] = a_radius - dist;
 
     // Capsule-side contact: world segment point pushed back by radius.
-    v3_quaternion_apply(out, 4, plx, ply, plz, b_qx, b_qy, b_qz, b_qw);
+    v[0] = plx; v[1] = ply; v[2] = plz;
+    v3_quaternion_apply_array(out, 4, v, 0, box, rotation);
     out[4] += b_cx - nx * a_radius;
     out[5] += b_cy - ny * a_radius;
     out[6] += b_cz - nz * a_radius;
 
     // Box-side contact: world projection of the box-surface point.
-    v3_quaternion_apply(out, 7, qlx, qly, qlz, b_qx, b_qy, b_qz, b_qw);
+    v[0] = qlx; v[1] = qly; v[2] = qlz;
+    v3_quaternion_apply_array(out, 7, v, 0, box, rotation);
     out[7] += b_cx;
     out[8] += b_cy;
     out[9] += b_cz;
@@ -555,12 +728,29 @@ export function capsule_box_multi_contacts(
     a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h,
     b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_hx, b_hy, b_hz
 ) {
+    const capsule = scratch_capsule_a;
+    const box = scratch_box_b;
+    capsule_pack(capsule, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h);
+    box_pack(box, b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_hx, b_hy, b_hz);
+    return capsule_box_multi_contacts_array(out, capsule, 0, box, 0);
+}
+
+/** A cap centre as a sphere of the capsule's radius, for {@link sphere_box_contact_array}. */
+const scratch_cap_sphere = new Float64Array(4);
+
+/**
+ * {@link capsule_box_multi_contacts} with the capsule (A) and the box (B) read from records.
+ *
+ * @param {Float64Array} out length >= CAPSULE_BOX_MAX_CONTACTS * CAPSULE_BOX_CONTACT_STRIDE
+ * @param {Float64Array} capsule
+ * @param {number} capsule_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ * @returns {number} number of contacts emitted, in `[0, CAPSULE_BOX_MAX_CONTACTS]`
+ */
+export function capsule_box_multi_contacts_array(out, capsule, capsule_offset, box, box_offset) {
     // 1. Primary contact: closest segment point vs OBB.
-    const primary_ok = capsule_box_contact(
-        scratch_primary,
-        a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_radius, a_half_h,
-        b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw, b_hx, b_hy, b_hz
-    );
+    const primary_ok = capsule_box_contact_array(scratch_primary, capsule, capsule_offset, box, box_offset);
     if (!primary_ok) return 0;
 
     // Repack scratch_primary (normal, depth, A, B) into the candidate stride
@@ -576,17 +766,15 @@ export function capsule_box_multi_contacts(
     let count = 1;
 
     // 2. Endpoint contacts: treat each cap centre as a sphere of cap-radius.
-    capsule_world_segment(scratch_seg, a_cx, a_cy, a_cz, a_qx, a_qy, a_qz, a_qw, a_half_h);
+    capsule_world_segment_array(scratch_seg, capsule, capsule_offset);
+
+    const cap = scratch_cap_sphere;
+    cap[3] = capsule[capsule_offset + 7];
 
     for (let i = 0; i < 2; i++) {
-        // Endpoint i lives at scratch_seg[i*3 .. i*3+2] — index directly rather
-        // than allocating three throwaway arrays per call (hot narrowphase path).
-        const ok = sphere_box_contact(
-            scratch_endpoint,
-            scratch_seg[i * 3], scratch_seg[i * 3 + 1], scratch_seg[i * 3 + 2], a_radius,
-            b_cx, b_cy, b_cz, b_qx, b_qy, b_qz, b_qw,
-            b_hx, b_hy, b_hz
-        );
+        // Endpoint i lives at scratch_seg[i*3 .. i*3+2].
+        cap[0] = scratch_seg[i * 3]; cap[1] = scratch_seg[i * 3 + 1]; cap[2] = scratch_seg[i * 3 + 2];
+        const ok = sphere_box_contact_array(scratch_endpoint, cap, 0, box, box_offset);
         if (!ok) continue;
 
         const e_nx = scratch_endpoint[0], e_ny = scratch_endpoint[1], e_nz = scratch_endpoint[2];

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

@@ -22,6 +22,19 @@
  * @returns {number} number of contacts emitted, in `[0, CAPSULE_TRIANGLE_MAX_CONTACTS]`
  */
 export function capsule_triangle_contact(out: number[] | Float64Array, c_cx: number, c_cy: number, c_cz: number, c_qx: number, c_qy: number, c_qz: number, c_qw: number, c_radius: number, c_half_h: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number;
+/**
+ * {@link capsule_triangle_contact} with the capsule and the triangle read from arrays: a call V8 does
+ * not inline boxes each number passed to it, eighteen here, once per triangle under a capsule.
+ *
+ * @param {Float64Array} out length >= CAPSULE_TRIANGLE_MAX_CONTACTS * CAPSULE_TRIANGLE_CONTACT_STRIDE
+ * @param {Float64Array} capsule centre (world), orientation (unit quaternion), radius, half-height
+ *   (not including caps) — nine numbers
+ * @param {number} capsule_offset
+ * @param {Float64Array} triangle vertices A, B, C (world)
+ * @param {number} triangle_offset
+ * @returns {number} number of contacts emitted, in `[0, CAPSULE_TRIANGLE_MAX_CONTACTS]`
+ */
+export function capsule_triangle_contact_array(out: Float64Array, capsule: Float64Array, capsule_offset: number, triangle: Float64Array, triangle_offset: number): number;
 /**
  * Multi-point capsule-vs-triangle contact generation.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"capsule_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_triangle_contact.js"],"names":[],"mappings":"AAoQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8CAtBW,MAAM,EAAE,GAAC,YAAY,QAErB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAqElB;AAzVD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;GAGG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;GAGG;AACH,4CAFU,MAAM,CAE+B"}
+{"version":3,"file":"capsule_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_triangle_contact.js"],"names":[],"mappings":"AAgRA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8CAtBW,MAAM,EAAE,GAAC,YAAY,QAErB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAmBlB;AAMD;;;;;;;;;;;GAWG;AACH,oDARW,YAAY,WACZ,YAAY,kBAEZ,MAAM,YACN,YAAY,mBACZ,MAAM,GACJ,MAAM,CAyElB;AA5YD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;GAGG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;GAGG;AACH,4CAFU,MAAM,CAE+B"}