@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -15,8 +15,9 @@
  *
  * @param {AbstractShape3D} shape
  * @param {ArrayLike<number>} position  body world position, indexed as
- *   [x, y, z] — a `Transform64`'s `translation` (what the raycast query
- *   passes), a `Vector3`, or a plain array. Read by index like `rotation`, so an
+ *   [x, y, z] — a retained array the pose was copied into (what the raycast
+ *   query passes; a `Transform64`'s `translation` would allocate a view per
+ *   read), a `Vector3`, or a plain array. Read by index like `rotation`, so an
  *   `{x, y, z}` object yields `NaN` or `Infinity` depending on the shape
  *   branch, and either way the body drops silently out of the cast
  * @param {ArrayLike<number>} rotation  body world rotation quaternion (x,y,z,w)

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

@@ -1 +1 @@
-{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AA6NA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,iEAlBW,UAAU,MAAM,CAAC,YAKjB,UAAU,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CA4BlB;AA7QD;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}
+{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AA6NA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iEAnBW,UAAU,MAAM,CAAC,YAMjB,UAAU,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CA4BlB;AA9QD;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}

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

@@ -236,8 +236,9 @@ function refine_ray_union(shape, ox, oy, oz, dx, dy, dz, tMax, outNormal) {
  *
  * @param {AbstractShape3D} shape
  * @param {ArrayLike<number>} position  body world position, indexed as
- *   [x, y, z] — a `Transform64`'s `translation` (what the raycast query
- *   passes), a `Vector3`, or a plain array. Read by index like `rotation`, so an
+ *   [x, y, z] — a retained array the pose was copied into (what the raycast
+ *   query passes; a `Transform64`'s `translation` would allocate a view per
+ *   read), a `Vector3`, or a plain array. Read by index like `rotation`, so an
  *   `{x, y, z}` object yields `NaN` or `Infinity` depending on the shape
  *   branch, and either way the body drops silently out of the cast
  * @param {ArrayLike<number>} rotation  body world rotation quaternion (x,y,z,w)

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

@@ -0,0 +1,27 @@
+/**
+ * The world pose of what a rigid `TransformedShape3D` wraps, given the wrapper's own world pose.
+ *
+ * A wrapper whose matrix is a rigid motion — unit, perpendicular columns, no reflection, affine — moves
+ * its subject without changing it, so the subject at the composed pose IS the wrapped shape:
+ * `p = p_pose + q_pose · t`, `q = q_pose ⊗ q_wrapper`. The narrowphase collides it there, through
+ * whatever routine the subject's type has, and the queries take a wrapped mesh or heightmap's triangles
+ * from it there. A wrapper that scales, shears or mirrors is no such thing, and is left as it is.
+ *
+ * The pose is passed as scalars, so a caller holding it as a `Transform64`, as arrays or as the `out`
+ * of an earlier call (a wrapper of a wrapper) passes it alike; every one is read before `out` is
+ * written.
+ *
+ * @param {import("../../ecs/transform/Transform64.js").Transform64} out receives the subject's world pose
+ * @param {import("../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D} shape
+ * @param {number} px the wrapper's world position
+ * @param {number} py
+ * @param {number} pz
+ * @param {number} qx the wrapper's world rotation, a unit quaternion
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @returns {boolean} whether `shape` is a TransformedShape3D with a subject and a rigid matrix; `out`
+ *   is untouched when it is not
+ */
+export function rigid_subject_pose(out: import("../../ecs/transform/Transform64.js").Transform64, shape: import("../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D, px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number): boolean;
+//# sourceMappingURL=rigid_subject_pose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rigid_subject_pose.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/rigid_subject_pose.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wCAZW,OAAO,oCAAoC,EAAE,WAAW,SACxD,OAAO,gDAAgD,EAAE,eAAe,MACxE,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAsBnB"}

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

@@ -0,0 +1,96 @@
+import { m4_decompose_array } from "../../../core/geom/3d/mat4/m4_decompose_array.js";
+import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
+
+/**
+ * How far a TransformedShape3D's matrix may be from a rigid motion — column lengths off 1, columns off
+ * perpendicular — and still be treated as one. A matrix handed over in float32 arrives rounded at
+ * about 1e-7, an exact rotation included.
+ * @type {number}
+ */
+const RIGID_TOLERANCE = 1e-5;
+
+/** Translation / rotation / scale of the wrapper matrix last passed to {@link decompose_rigid}. */
+const wrapper_translation = new Float64Array(3);
+const wrapper_rotation = new Float64Array(4);
+const wrapper_scale = new Float64Array(3);
+
+/** The wrapper's translation rotated into the world, by {@link rigid_subject_pose}. */
+const wrapper_offset = new Float64Array(3);
+
+/**
+ * Whether an affine matrix (column-major) is a rigid motion, leaving its translation and rotation in
+ * {@link wrapper_translation} / {@link wrapper_rotation}.
+ *
+ * @param {ArrayLike<number>} m
+ * @returns {boolean}
+ */
+function decompose_rigid(m) {
+    if (m[3] !== 0 || m[7] !== 0 || m[11] !== 0 || m[15] !== 1) {
+        return false;
+    }
+
+    // a reflection comes back as a negative x scale, so it fails here too
+    m4_decompose_array(m, wrapper_translation, 0, wrapper_rotation, 0, wrapper_scale, 0);
+
+    if (Math.abs(wrapper_scale[0] - 1) > RIGID_TOLERANCE
+        || Math.abs(wrapper_scale[1] - 1) > RIGID_TOLERANCE
+        || Math.abs(wrapper_scale[2] - 1) > RIGID_TOLERANCE) {
+        return false;
+    }
+
+    // the decomposition assumes no shear; a sheared matrix has unit columns that are not perpendicular
+    const d01 = m[0] * m[4] + m[1] * m[5] + m[2] * m[6];
+    const d02 = m[0] * m[8] + m[1] * m[9] + m[2] * m[10];
+    const d12 = m[4] * m[8] + m[5] * m[9] + m[6] * m[10];
+
+    return Math.abs(d01) <= RIGID_TOLERANCE
+        && Math.abs(d02) <= RIGID_TOLERANCE
+        && Math.abs(d12) <= RIGID_TOLERANCE;
+}
+
+/**
+ * The world pose of what a rigid `TransformedShape3D` wraps, given the wrapper's own world pose.
+ *
+ * A wrapper whose matrix is a rigid motion — unit, perpendicular columns, no reflection, affine — moves
+ * its subject without changing it, so the subject at the composed pose IS the wrapped shape:
+ * `p = p_pose + q_pose · t`, `q = q_pose ⊗ q_wrapper`. The narrowphase collides it there, through
+ * whatever routine the subject's type has, and the queries take a wrapped mesh or heightmap's triangles
+ * from it there. A wrapper that scales, shears or mirrors is no such thing, and is left as it is.
+ *
+ * The pose is passed as scalars, so a caller holding it as a `Transform64`, as arrays or as the `out`
+ * of an earlier call (a wrapper of a wrapper) passes it alike; every one is read before `out` is
+ * written.
+ *
+ * @param {import("../../ecs/transform/Transform64.js").Transform64} out receives the subject's world pose
+ * @param {import("../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D} shape
+ * @param {number} px the wrapper's world position
+ * @param {number} py
+ * @param {number} pz
+ * @param {number} qx the wrapper's world rotation, a unit quaternion
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @returns {boolean} whether `shape` is a TransformedShape3D with a subject and a rigid matrix; `out`
+ *   is untouched when it is not
+ */
+export function rigid_subject_pose(out, shape, px, py, pz, qx, qy, qz, qw) {
+    if (shape.isTransformedShape3D !== true || shape.subject === null || !decompose_rigid(shape.transform)) {
+        return false;
+    }
+
+    // subject pose = pose ∘ wrapper: p = p_pose + q_pose · t, q = q_pose ⊗ q_wrapper
+    v3_quaternion_apply(wrapper_offset, 0,
+        wrapper_translation[0], wrapper_translation[1], wrapper_translation[2],
+        qx, qy, qz, qw
+    );
+    quat3_multiply(wrapper_rotation, 0,
+        qx, qy, qz, qw,
+        wrapper_rotation[0], wrapper_rotation[1], wrapper_rotation[2], wrapper_rotation[3]
+    );
+
+    out.setTranslation(px + wrapper_offset[0], py + wrapper_offset[1], pz + wrapper_offset[2]);
+    out.setRotation(wrapper_rotation[0], wrapper_rotation[1], wrapper_rotation[2], wrapper_rotation[3]);
+
+    return true;
+}

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

@@ -35,4 +35,18 @@
  * @returns {boolean} true if overlap
  */
 export function sphere_box_contact(out: number[] | Float64Array, sx: number, sy: number, sz: number, radius: number, bx: number, by: number, bz: number, bqx: number, bqy: number, bqz: number, bqw: number, hx: number, hy: number, hz: number): boolean;
+/**
+ * {@link sphere_box_contact} with the sphere read from an array as `[centre, radius]` and the box as
+ * `[centre, orientation (unit quaternion), half-extents]`. A call V8 does not inline boxes each number
+ * passed to it, fourteen here, once per sphere-box pair, and the same goes for the rotations inside, so
+ * those take arrays too.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} sphere
+ * @param {number} sphere_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ * @returns {boolean} true if overlap
+ */
+export function sphere_box_contact_array(out: number[] | Float64Array, sphere: Float64Array, sphere_offset: number, box: Float64Array, box_offset: number): boolean;
 //# sourceMappingURL=sphere_box_contact.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sphere_box_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_box_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAjBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAuFnB"}
+{"version":3,"file":"sphere_box_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_box_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAjBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmBnB;AASD;;;;;;;;;;;;GAYG;AACH,8CAPW,MAAM,EAAE,GAAC,YAAY,UACrB,YAAY,iBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CA8FnB"}

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

@@ -1,5 +1,5 @@
-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 { 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";
 
 /**
  * Scratch for the world→box-local rotation of the sphere centre at the
@@ -51,9 +51,52 @@ export function sphere_box_contact(
     bqx, bqy, bqz, bqw,
     hx, hy, hz
 ) {
+    const sphere = scratch_sphere;
+    const box = scratch_box;
+
+    sphere[0] = sx; sphere[1] = sy; sphere[2] = sz; sphere[3] = radius;
+
+    box[0] = bx; box[1] = by; box[2] = bz;
+    box[3] = bqx; box[4] = bqy; box[5] = bqz; box[6] = bqw;
+    box[7] = hx; box[8] = hy; box[9] = hz;
+
+    return sphere_box_contact_array(out, sphere, 0, box, 0);
+}
+
+/** Where {@link sphere_box_contact} packs its sphere and its box. */
+const scratch_sphere = new Float64Array(4);
+const scratch_box = new Float64Array(10);
+
+/** The box-local vectors {@link sphere_box_contact_array} rotates back to world. */
+const scratch_vector = new Float64Array(3);
+
+/**
+ * {@link sphere_box_contact} with the sphere read from an array as `[centre, radius]` and the box as
+ * `[centre, orientation (unit quaternion), half-extents]`. A call V8 does not inline boxes each number
+ * passed to it, fourteen here, once per sphere-box pair, and the same goes for the rotations inside, so
+ * those take arrays too.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} sphere
+ * @param {number} sphere_offset
+ * @param {Float64Array} box
+ * @param {number} box_offset
+ * @returns {boolean} true if overlap
+ */
+export function sphere_box_contact_array(out, sphere, sphere_offset, box, box_offset) {
+    const sx = sphere[sphere_offset], sy = sphere[sphere_offset + 1], sz = sphere[sphere_offset + 2];
+    const radius = sphere[sphere_offset + 3];
+
+    const bx = box[box_offset], by = box[box_offset + 1], bz = box[box_offset + 2];
+    const hx = box[box_offset + 7], hy = box[box_offset + 8], hz = box[box_offset + 9];
+    const rotation = box_offset + 3;
+
     // Step 1: bring the sphere centre into box-local space via the conjugate
     // quaternion. v_local = q* · (s - b) · q
-    v3_quaternion_apply_inverse(scratch_local, 0, sx - bx, sy - by, sz - bz, bqx, bqy, bqz, bqw);
+    scratch_local[0] = sx - bx;
+    scratch_local[1] = sy - by;
+    scratch_local[2] = sz - bz;
+    v3_quaternion_apply_inverse_array(scratch_local, 0, scratch_local, 0, box, rotation);
     const lx = scratch_local[0];
     const ly = scratch_local[1];
     const lz = scratch_local[2];
@@ -113,7 +156,9 @@ export function sphere_box_contact(
     // Step 3: rotate normal and surface point back to world. v_world = q · v · q*
 
     // World normal (box → sphere).
-    v3_quaternion_apply(out, 0, nlx, nly, nlz, bqx, bqy, bqz, bqw);
+    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] = radius - dist;
 
@@ -123,7 +168,8 @@ export function sphere_box_contact(
     out[6] = sz - nz * radius;
 
     // World contact on box: rotate the local-space clamped point to world, plus box centre.
-    v3_quaternion_apply(out, 7, clx, cly, clz, bqx, bqy, bqz, bqw);
+    v[0] = clx; v[1] = cly; v[2] = clz;
+    v3_quaternion_apply_array(out, 7, v, 0, box, rotation);
     out[7] += bx;
     out[8] += by;
     out[9] += bz;

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

@@ -24,4 +24,16 @@
  * @returns {boolean} true if spheres overlap
  */
 export function sphere_sphere_contact(out: number[] | Float64Array, ax: number, ay: number, az: number, bx: number, by: number, bz: number, radius_a: number, radius_b: number): boolean;
+/**
+ * {@link sphere_sphere_contact} with each sphere read from an array as `[centre, radius]`: a call V8
+ * does not inline boxes each number passed to it, eight here, once per sphere pair.
+ *
+ * @param {number[]|Float64Array} out length >= 4
+ * @param {Float64Array} sphere_a
+ * @param {number} sphere_a_offset
+ * @param {Float64Array} sphere_b
+ * @param {number} sphere_b_offset
+ * @returns {boolean} true if spheres overlap
+ */
+export function sphere_sphere_contact_array(out: number[] | Float64Array, sphere_a: Float64Array, sphere_a_offset: number, sphere_b: Float64Array, sphere_b_offset: number): boolean;
 //# sourceMappingURL=sphere_sphere_contact.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sphere_sphere_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_sphere_contact.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,2CAXW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,GACJ,OAAO,CA4BnB"}
+{"version":3,"file":"sphere_sphere_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_sphere_contact.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,2CAXW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,GACJ,OAAO,CAUnB;AAMD;;;;;;;;;;GAUG;AACH,iDAPW,MAAM,EAAE,GAAC,YAAY,YACrB,YAAY,mBACZ,MAAM,YACN,YAAY,mBACZ,MAAM,GACJ,OAAO,CAiCnB"}

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

@@ -24,6 +24,36 @@
  * @returns {boolean} true if spheres overlap
  */
 export function sphere_sphere_contact(out, ax, ay, az, bx, by, bz, radius_a, radius_b) {
+    const a = scratch_sphere_a;
+    const b = scratch_sphere_b;
+
+    a[0] = ax; a[1] = ay; a[2] = az; a[3] = radius_a;
+    b[0] = bx; b[1] = by; b[2] = bz; b[3] = radius_b;
+
+    return sphere_sphere_contact_array(out, a, 0, b, 0);
+}
+
+/** Where {@link sphere_sphere_contact} packs its spheres. */
+const scratch_sphere_a = new Float64Array(4);
+const scratch_sphere_b = new Float64Array(4);
+
+/**
+ * {@link sphere_sphere_contact} with each sphere read from an array as `[centre, radius]`: a call V8
+ * does not inline boxes each number passed to it, eight here, once per sphere pair.
+ *
+ * @param {number[]|Float64Array} out length >= 4
+ * @param {Float64Array} sphere_a
+ * @param {number} sphere_a_offset
+ * @param {Float64Array} sphere_b
+ * @param {number} sphere_b_offset
+ * @returns {boolean} true if spheres overlap
+ */
+export function sphere_sphere_contact_array(out, sphere_a, sphere_a_offset, sphere_b, sphere_b_offset) {
+    const ax = sphere_a[sphere_a_offset], ay = sphere_a[sphere_a_offset + 1], az = sphere_a[sphere_a_offset + 2];
+    const radius_a = sphere_a[sphere_a_offset + 3];
+    const bx = sphere_b[sphere_b_offset], by = sphere_b[sphere_b_offset + 1], bz = sphere_b[sphere_b_offset + 2];
+    const radius_b = sphere_b[sphere_b_offset + 3];
+
     const dx = ax - bx;
     const dy = ay - by;
     const dz = az - bz;

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

@@ -45,4 +45,16 @@
  * @returns {boolean} true if sphere overlaps the triangle
  */
 export function sphere_triangle_contact(out: number[] | Float64Array, sx: number, sy: number, sz: number, radius: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): boolean;
+/**
+ * {@link sphere_triangle_contact} with the sphere and the triangle read from arrays: a call V8 does not
+ * inline boxes each number passed to it, thirteen here, once per triangle under a sphere.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} sphere centre (world) then radius
+ * @param {number} sphere_offset
+ * @param {Float64Array} triangle vertices A, B, C (world)
+ * @param {number} triangle_offset
+ * @returns {boolean} true if sphere overlaps the triangle
+ */
+export function sphere_triangle_contact_array(out: number[] | Float64Array, sphere: Float64Array, sphere_offset: number, triangle: Float64Array, triangle_offset: number): boolean;
 //# sourceMappingURL=sphere_triangle_contact.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sphere_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_triangle_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,6CAhBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmFnB"}
+{"version":3,"file":"sphere_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_triangle_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,6CAhBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmBnB;AAMD;;;;;;;;;;GAUG;AACH,mDAPW,MAAM,EAAE,GAAC,YAAY,UACrB,YAAY,iBACZ,MAAM,YACN,YAAY,mBACZ,MAAM,GACJ,OAAO,CA8EnB"}

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

@@ -1,4 +1,4 @@
-import { tri3_closest_point } from "../../../core/geom/3d/triangle/tri3_closest_point.js";
+import { tri3_closest_point_array } from "../../../core/geom/3d/triangle/tri3_closest_point.js";
 
 /**
  * Closest-point on triangle, written into the first two floats of `out`
@@ -61,6 +61,41 @@ export function sphere_triangle_contact(
     bx, by, bz,
     cx, cy, cz
 ) {
+    const sphere = scratch_sphere;
+    const triangle = scratch_triangle;
+
+    sphere[0] = sx; sphere[1] = sy; sphere[2] = sz; sphere[3] = radius;
+
+    triangle[0] = ax; triangle[1] = ay; triangle[2] = az;
+    triangle[3] = bx; triangle[4] = by; triangle[5] = bz;
+    triangle[6] = cx; triangle[7] = cy; triangle[8] = cz;
+
+    return sphere_triangle_contact_array(out, sphere, 0, triangle, 0);
+}
+
+/** Where {@link sphere_triangle_contact} packs its sphere and its triangle. */
+const scratch_sphere = new Float64Array(4);
+const scratch_triangle = new Float64Array(9);
+
+/**
+ * {@link sphere_triangle_contact} with the sphere and the triangle read from arrays: a call V8 does not
+ * inline boxes each number passed to it, thirteen here, once per triangle under a sphere.
+ *
+ * @param {number[]|Float64Array} out length >= 10
+ * @param {Float64Array} sphere centre (world) then radius
+ * @param {number} sphere_offset
+ * @param {Float64Array} triangle vertices A, B, C (world)
+ * @param {number} triangle_offset
+ * @returns {boolean} true if sphere overlaps the triangle
+ */
+export function sphere_triangle_contact_array(out, sphere, sphere_offset, triangle, triangle_offset) {
+    const sx = sphere[sphere_offset], sy = sphere[sphere_offset + 1], sz = sphere[sphere_offset + 2];
+    const radius = sphere[sphere_offset + 3];
+
+    const ax = triangle[triangle_offset], ay = triangle[triangle_offset + 1], az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3], by = triangle[triangle_offset + 4], bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6], cy = triangle[triangle_offset + 7], cz = triangle[triangle_offset + 8];
+
     // Degenerate-triangle guard. For zero-area triangles (colinear or
     // duplicate vertices) the closest-point algorithm still returns
     // a point on the degenerate "line" but the surrounding geometry
@@ -79,13 +114,7 @@ export function sphere_triangle_contact(
     if (fn_mag_sqr === 0) return false;
 
     // Closest-point on triangle to sphere centre — barycentric output.
-    tri3_closest_point(
-        scratch_closest, 0,
-        sx, sy, sz,
-        ax, ay, az,
-        bx, by, bz,
-        cx, cy, cz
-    );
+    tri3_closest_point_array(scratch_closest, 0, sphere, sphere_offset, triangle, triangle_offset);
     const px = scratch_closest[0];
     const py = scratch_closest[1];
     const pz = scratch_closest[2];

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

@@ -0,0 +1,139 @@
+/**
+ * The supporting feature of a posed convex shape along a world direction — see the module notes.
+ *
+ * @param {SupportFeature} f receives the feature
+ * @param {AbstractShape3D|{vertices, face_offsets, face_loops, support}} shape
+ * @param {number} px shape position x
+ * @param {number} py
+ * @param {number} pz
+ * @param {number} qx shape rotation quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} dx unit world direction, toward the other body
+ * @param {number} dy
+ * @param {number} dz
+ */
+export function support_feature(f: SupportFeature, shape: AbstractShape3D | {
+    vertices;
+    face_offsets;
+    face_loops;
+    support;
+}, px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number, dx: number, dy: number, dz: number): void;
+/**
+ * The supporting feature of a world triangle along a direction: the triangle itself when its outward
+ * normal is within {@link FACE_ALIGNMENT} of the direction, else the vertices tied at the extreme.
+ *
+ * @param {SupportFeature} f
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @param {number} nx unit outward normal of the triangle
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} dx unit direction, toward the other body
+ * @param {number} dy
+ * @param {number} dz
+ */
+export function triangle_feature(f: SupportFeature, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number, nx: number, ny: number, nz: number, dx: number, dy: number, dz: number): void;
+/**
+ * Contacts between two supporting features, along the axis `n` (unit, from B toward A) the pair
+ * penetrates along by `depth`. A's feature must face B (taken along −n), B's face A (along +n).
+ *
+ * When either feature is a face, the other is clipped to that face's prism and every point that
+ * reaches behind it is a contact, at the depth it reaches, with the face's own normal — the exact
+ * normal of a face-on-face contact, however rough the axis it was found along. Otherwise, or when
+ * the clip leaves nothing, one contact: two segments meet at their closest points; anything else on
+ * the smaller feature's centroid, projected along `n` onto the other side's support plane, at
+ * `depth`.
+ *
+ * Layout matches {@link convex_hull_clip}: `out[0..2]` the normal (B→A), `out[3]` the count, then
+ * per contact the point on A, the point on B and the depth.
+ *
+ * @param {Float64Array} out length ≥ {@link FEATURE_MANIFOLD_OUT_LENGTH}
+ * @param {SupportFeature} fa
+ * @param {SupportFeature} fb
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} depth
+ */
+export function feature_manifold(out: Float64Array, fa: SupportFeature, fb: SupportFeature, nx: number, ny: number, nz: number, depth: number): void;
+/**
+ * Contact points for a convex pair the narrowphase has an axis and a depth for (GJK + EPA) but no
+ * dedicated routine: a cylinder against anything, a capsule against a hull, a hull or a cylinder
+ * against a mesh triangle, a scaled TransformedShape3D.
+ *
+ * Each side contributes its SUPPORTING FEATURE along the axis — the face, edge or point of it that
+ * faces the other body — and the two are clipped against each other, as Jolt's
+ * `ManifoldBetweenTwoFaces` and Box3D's capsule/hull face contact do: a cylinder standing on its cap
+ * gets the cap's rim, clipped to the floor face, and stands; a capsule lying on a hull face gets
+ * both ends of its segment. Where the features do not face each other squarely there is one contact,
+ * on the smaller feature, projected along the axis onto the other body — never at a body's origin,
+ * which is what this path used to report, putting the push metres from where the bodies touch.
+ *
+ * Features:
+ *   - box, convex hull (any `{vertices, face_offsets, face_loops}` polytope), triangle: the face whose
+ *     outward normal is within {@link FACE_ALIGNMENT} of the direction; otherwise the vertices tied
+ *     at the extreme (an edge, or a vertex);
+ *   - cylinder: the cap, as {@link CYLINDER_CAP_POINTS} rim points, within FACE_ALIGNMENT of its
+ *     axis; the side line, within the same angle of perpendicular; otherwise the support point;
+ *   - capsule: its segment's two hemisphere support points, within that angle of perpendicular;
+ *     otherwise the support point;
+ *   - TransformedShape3D (one that scales; rigid ones are collided as their subject): the subject's
+ *     feature along the direction mapped into it, carried through the matrix;
+ *   - anything else: the support point.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/** @type {number} */
+export const FEATURE_POINT: number;
+/** @type {number} */
+export const FEATURE_SEGMENT: number;
+/** @type {number} */
+export const FEATURE_POLYGON: number;
+/**
+ * The part of a convex shape that faces a direction, in world space.
+ */
+export class SupportFeature {
+    /**
+     * World points, flat `(x, y, z)`. A POLYGON's are in loop order.
+     * @type {Float64Array}
+     */
+    points: Float64Array;
+    /** @type {number} */
+    count: number;
+    /**
+     * {@link FEATURE_POINT}, {@link FEATURE_SEGMENT} or {@link FEATURE_POLYGON}.
+     * @type {number}
+     */
+    kind: number;
+    /**
+     * Unit outward normal of a POLYGON feature, world.
+     */
+    nx: number;
+    ny: number;
+    nz: number;
+    /**
+     * The shape's furthest projection on the direction, `max(p · d)`: its support plane along it.
+     * @type {number}
+     */
+    extreme: number;
+    /**
+     * @param {number} n points about to be written
+     */
+    reserve(n: number): void;
+}
+/**
+ * Output length of {@link feature_manifold}: `[nx, ny, nz, count, (ax, ay, az, bx, by, bz, depth) × 4]`.
+ * @type {number}
+ */
+export const FEATURE_MANIFOLD_OUT_LENGTH: number;
+//# sourceMappingURL=support_feature_manifold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"support_feature_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/support_feature_manifold.js"],"names":[],"mappings":"AAweA;;;;;;;;;;;;;;;GAeG;AACH,mCAbW,cAAc,SACd,kBAAgB;IAAC,QAAQ,CAAC;IAAC,YAAY,CAAC;IAAC,UAAU,CAAC;IAAC,OAAO,CAAA;CAAC,MAC7D,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkChB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAjBW,cAAc,MACd,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAyBhB;AAwOD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,sCARW,YAAY,MACZ,cAAc,MACd,cAAc,MACd,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,QAkHhB;AA96BD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,qBAAqB;AACrB,4BADW,MAAM,CACc;AAC/B,qBAAqB;AACrB,8BADW,MAAM,CACgB;AACjC,qBAAqB;AACrB,8BADW,MAAM,CACgB;AA+BjC;;GAEG;AACH;IACI;;;OAGG;IACH,QAFU,YAAY,CAEY;IAElC,qBAAqB;IACrB,OADW,MAAM,CACP;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEK;IAErB;;OAEG;IACH,WAAO;IACP,WAAO;IACP,WAAO;IAEP;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,WAFW,MAAM,QAMhB;CACJ;AAyrBD;;;GAGG;AACH,0CAFU,MAAM,CAEqC"}