@woosh/meep-engine 3.38.0 → 3.40.0

package/src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js

@@ -21,7 +21,13 @@
  *
  * Stride 10 (rather than 9) is the small cost we pay for clean warm-start
  * matching; ID-based matching beats position-distance matching when shapes
- * slide along curved surfaces.
+ * slide along curved surfaces. {@link triangle_edge_flags} reads an entry
+ * to say which of the triangle's edges are real.
+ *
+ * A vertex two triangles share has the same coordinates, bit for bit, in
+ * both entries — both enumerators copy or compute each one by one expression
+ * — so a vertex or an edge can be recognised across triangles by its
+ * coordinates.
  *
  * @readonly
  * @type {number}

package/src/engine/physics/narrowphase/decomposition/triangle_edge_flags.d.ts

@@ -0,0 +1,35 @@
+/**
+ * {@link TriangleEdgeFlags} of the edges of one triangle {@link decompose_to_triangles} wrote into a
+ * triangle buffer for a non-convex shape: which of its edges A→B, B→C, C→A are FLAT to the neighbour
+ * across them (an edge of the triangulation, not of the surface), which CONCAVE; the rest are real.
+ * Edge bits only; a corner is asked about with {@link triangle_vertex_flat}.
+ *
+ * A mesh's are computed once for the shape and kept ({@link MeshShape3D#get_triangle_edge_flags}),
+ * found by the entry's feature id; a heightmap's are computed per call from the entry and a few
+ * samples ({@link heightmap_triangle_edge_flags}). The narrowphase asks only for the triangles whose
+ * contacts lie on an edge or a vertex.
+ *
+ * Throws for a shape with no triangle enumerator, as {@link decompose_to_triangles} does.
+ *
+ * @param {AbstractShape3D} shape (must have `is_convex === false`)
+ * @param {Float64Array} triangles a triangle buffer {@link decompose_to_triangles} wrote for `shape`
+ * @param {number} offset float index of the triangle's entry
+ * @returns {number}
+ */
+export function triangle_edge_flags(shape: AbstractShape3D, triangles: Float64Array, offset: number): number;
+/**
+ * Whether corner `k` (0..2: A, B, C) of one triangle {@link decompose_to_triangles} wrote into a
+ * triangle buffer is a FLAT vertex ({@link TriangleEdgeFlags.FlatVertexA}): every edge of the surface
+ * meeting there is flat, so the vertex is an artefact of triangulation, not a corner of the surface.
+ *
+ * A mesh's are kept with its edge flags; a heightmap's are sampled per call, six neighbours
+ * ({@link heightmap_triangle_vertex_flat}).
+ *
+ * @param {AbstractShape3D} shape (must have `is_convex === false`)
+ * @param {Float64Array} triangles a triangle buffer {@link decompose_to_triangles} wrote for `shape`
+ * @param {number} offset float index of the triangle's entry
+ * @param {number} k corner
+ * @returns {boolean}
+ */
+export function triangle_vertex_flat(shape: AbstractShape3D, triangles: Float64Array, offset: number, k: number): boolean;
+//# sourceMappingURL=triangle_edge_flags.d.ts.map

package/src/engine/physics/narrowphase/decomposition/triangle_edge_flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangle_edge_flags.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/triangle_edge_flags.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,uEAJW,YAAY,UACZ,MAAM,GACJ,MAAM,CAalB;AAED;;;;;;;;;;;;;GAaG;AACH,wEALW,YAAY,UACZ,MAAM,KACN,MAAM,GACJ,OAAO,CAanB"}

package/src/engine/physics/narrowphase/decomposition/triangle_edge_flags.js

@@ -0,0 +1,61 @@
+import { TRIANGLE_EDGE_BITS, TriangleEdgeFlags } from "../../../../core/geom/3d/triangle/TriangleEdgeFlags.js";
+import { heightmap_triangle_edge_flags, heightmap_triangle_vertex_flat } from "./heightmap_triangle_edge_flags.js";
+import { TRIANGLE_FEATURE_ID_OFFSET } from "./triangle_buffer_layout.js";
+
+/**
+ * {@link TriangleEdgeFlags} of the edges of one triangle {@link decompose_to_triangles} wrote into a
+ * triangle buffer for a non-convex shape: which of its edges A→B, B→C, C→A are FLAT to the neighbour
+ * across them (an edge of the triangulation, not of the surface), which CONCAVE; the rest are real.
+ * Edge bits only; a corner is asked about with {@link triangle_vertex_flat}.
+ *
+ * A mesh's are computed once for the shape and kept ({@link MeshShape3D#get_triangle_edge_flags}),
+ * found by the entry's feature id; a heightmap's are computed per call from the entry and a few
+ * samples ({@link heightmap_triangle_edge_flags}). The narrowphase asks only for the triangles whose
+ * contacts lie on an edge or a vertex.
+ *
+ * Throws for a shape with no triangle enumerator, as {@link decompose_to_triangles} does.
+ *
+ * @param {AbstractShape3D} shape (must have `is_convex === false`)
+ * @param {Float64Array} triangles a triangle buffer {@link decompose_to_triangles} wrote for `shape`
+ * @param {number} offset float index of the triangle's entry
+ * @returns {number}
+ */
+export function triangle_edge_flags(shape, triangles, offset) {
+    if (shape.isMeshShape3D === true) {
+        // the enumerator's fid is the triangle's index + 1
+        return shape.get_triangle_edge_flags()[triangles[offset + TRIANGLE_FEATURE_ID_OFFSET] - 1] & TRIANGLE_EDGE_BITS;
+    }
+
+    if (shape.isHeightMapShape3D === true) {
+        return heightmap_triangle_edge_flags(shape, triangles, offset);
+    }
+
+    throw new Error(`triangle_edge_flags: no triangle enumerator for shape kind \`${shape.constructor.name}\``);
+}
+
+/**
+ * Whether corner `k` (0..2: A, B, C) of one triangle {@link decompose_to_triangles} wrote into a
+ * triangle buffer is a FLAT vertex ({@link TriangleEdgeFlags.FlatVertexA}): every edge of the surface
+ * meeting there is flat, so the vertex is an artefact of triangulation, not a corner of the surface.
+ *
+ * A mesh's are kept with its edge flags; a heightmap's are sampled per call, six neighbours
+ * ({@link heightmap_triangle_vertex_flat}).
+ *
+ * @param {AbstractShape3D} shape (must have `is_convex === false`)
+ * @param {Float64Array} triangles a triangle buffer {@link decompose_to_triangles} wrote for `shape`
+ * @param {number} offset float index of the triangle's entry
+ * @param {number} k corner
+ * @returns {boolean}
+ */
+export function triangle_vertex_flat(shape, triangles, offset, k) {
+    if (shape.isMeshShape3D === true) {
+        const flags = shape.get_triangle_edge_flags()[triangles[offset + TRIANGLE_FEATURE_ID_OFFSET] - 1];
+        return (flags & (TriangleEdgeFlags.FlatVertexA << k)) !== 0;
+    }
+
+    if (shape.isHeightMapShape3D === true) {
+        return heightmap_triangle_vertex_flat(shape, triangles, offset, k);
+    }
+
+    throw new Error(`triangle_vertex_flat: no triangle enumerator for shape kind \`${shape.constructor.name}\``);
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Closed-form contact between a convex hull and a sphere: the closest point on the hull to the
+ * sphere's centre, and the sphere's point deepest along the normal through it.
+ *
+ * After Box3D's `b3CollideHullAndSphere` (convex_manifold.c; Box3D, Erin Catto, MIT licence): a
+ * centre outside the hull is pushed out along the line to its closest surface point; a centre on or
+ * inside the surface along the normal of the face it is least far behind — the plane of maximum
+ * separation, which for a convex polytope is the nearest face. Box3D finds the outside closest point
+ * with GJK. Here, for a centre over the face it is furthest in front of — a sphere resting on a side —
+ * it is the foot of the perpendicular to that face, found by the same O(F) scan of one plane per side;
+ * only off an edge or a corner does it take {@link ConvexHullShape3D#nearest_point_on_surface}, the
+ * hull's own O(F) surface scan of its triangles. (A GJK distance query would make that last case
+ * O(V) per iteration; there is none in the engine yet.)
+ *
+ * The contact lies on the line through the sphere's centre, so a contact the solver acts on — at the
+ * witnesses' midpoint, along the normal — has no moment about the sphere: a frictionless sphere is
+ * stopped by a hull without being spun.
+ *
+ * Output convention (mirrors {@link sphere_box_contact}): `out[0..2]` the unit normal from the hull's
+ * surface toward the sphere's centre; `out[3]` the penetration depth (positive); `out[4..6]` the
+ * world point on the sphere's surface; `out[7..9]` the world point on the hull's surface.
+ *
+ * @param {number[]|Float64Array} out length ≥ 10
+ * @param {ConvexHullShape3D} hull
+ * @param {number} px hull position x
+ * @param {number} py
+ * @param {number} pz
+ * @param {number} qx hull rotation quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} sx sphere centre x
+ * @param {number} sy
+ * @param {number} sz
+ * @param {number} radius
+ * @returns {boolean} true if they overlap
+ */
+export function hull_sphere_contact(out: number[] | Float64Array, hull: ConvexHullShape3D, px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number, sx: number, sy: number, sz: number, radius: number): boolean;
+/**
+ * {@link hull_sphere_contact} with the hull's pose read from an array as `[position, orientation
+ * (unit quaternion)]` and the sphere as `[centre, radius]`: a call V8 does not inline boxes each
+ * number passed to it, eleven here, once per hull-sphere pair, and the same goes for the rotations
+ * inside, so those take arrays too.
+ *
+ * @param {number[]|Float64Array} out length ≥ 10
+ * @param {ConvexHullShape3D} hull
+ * @param {Float64Array} pose
+ * @param {number} pose_offset
+ * @param {Float64Array} sphere
+ * @param {number} sphere_offset
+ * @returns {boolean} true if they overlap
+ */
+export function hull_sphere_contact_array(out: number[] | Float64Array, hull: ConvexHullShape3D, pose: Float64Array, pose_offset: number, sphere: Float64Array, sphere_offset: number): boolean;
+//# sourceMappingURL=hull_sphere_contact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hull_sphere_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/hull_sphere_contact.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,yCAfW,MAAM,EAAE,GAAC,YAAY,+BAErB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,GACJ,OAAO,CAkBnB;AASD;;;;;;;;;;;;;GAaG;AACH,+CARW,MAAM,EAAE,GAAC,YAAY,iCAErB,YAAY,eACZ,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,OAAO,CAsHnB"}

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

@@ -0,0 +1,244 @@
+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";
+
+/**
+ * Below this distance from the hull's surface the direction from the closest surface point to the
+ * sphere centre is noise, and the contact takes the hull's least-penetrated face instead — Box3D's
+ * `100 · FLT_EPSILON`.
+ * @type {number}
+ */
+const SHALLOW_DISTANCE = 100 * 1.1920928955078125e-7;
+
+/** Sphere centre in the hull's frame, then (reused) the closest surface point. */
+const scratch_centre = new Float64Array(3);
+const scratch_closest = new Float64Array(3);
+const scratch_world = new Float64Array(3);
+
+/**
+ * Closed-form contact between a convex hull and a sphere: the closest point on the hull to the
+ * sphere's centre, and the sphere's point deepest along the normal through it.
+ *
+ * After Box3D's `b3CollideHullAndSphere` (convex_manifold.c; Box3D, Erin Catto, MIT licence): a
+ * centre outside the hull is pushed out along the line to its closest surface point; a centre on or
+ * inside the surface along the normal of the face it is least far behind — the plane of maximum
+ * separation, which for a convex polytope is the nearest face. Box3D finds the outside closest point
+ * with GJK. Here, for a centre over the face it is furthest in front of — a sphere resting on a side —
+ * it is the foot of the perpendicular to that face, found by the same O(F) scan of one plane per side;
+ * only off an edge or a corner does it take {@link ConvexHullShape3D#nearest_point_on_surface}, the
+ * hull's own O(F) surface scan of its triangles. (A GJK distance query would make that last case
+ * O(V) per iteration; there is none in the engine yet.)
+ *
+ * The contact lies on the line through the sphere's centre, so a contact the solver acts on — at the
+ * witnesses' midpoint, along the normal — has no moment about the sphere: a frictionless sphere is
+ * stopped by a hull without being spun.
+ *
+ * Output convention (mirrors {@link sphere_box_contact}): `out[0..2]` the unit normal from the hull's
+ * surface toward the sphere's centre; `out[3]` the penetration depth (positive); `out[4..6]` the
+ * world point on the sphere's surface; `out[7..9]` the world point on the hull's surface.
+ *
+ * @param {number[]|Float64Array} out length ≥ 10
+ * @param {ConvexHullShape3D} hull
+ * @param {number} px hull position x
+ * @param {number} py
+ * @param {number} pz
+ * @param {number} qx hull rotation quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} sx sphere centre x
+ * @param {number} sy
+ * @param {number} sz
+ * @param {number} radius
+ * @returns {boolean} true if they overlap
+ */
+export function hull_sphere_contact(
+    out,
+    hull,
+    px, py, pz,
+    qx, qy, qz, qw,
+    sx, sy, sz, radius
+) {
+    const pose = scratch_pose;
+    const sphere = scratch_sphere;
+
+    pose[0] = px; pose[1] = py; pose[2] = pz;
+    pose[3] = qx; pose[4] = qy; pose[5] = qz; pose[6] = qw;
+
+    sphere[0] = sx; sphere[1] = sy; sphere[2] = sz; sphere[3] = radius;
+
+    return hull_sphere_contact_array(out, hull, pose, 0, sphere, 0);
+}
+
+/** Where {@link hull_sphere_contact} packs the hull's pose and the sphere. */
+const scratch_pose = new Float64Array(7);
+const scratch_sphere = new Float64Array(4);
+
+/** The hull-local normal, staged to be rotated to world. */
+const scratch_normal = new Float64Array(3);
+
+/**
+ * {@link hull_sphere_contact} with the hull's pose read from an array as `[position, orientation
+ * (unit quaternion)]` and the sphere as `[centre, radius]`: a call V8 does not inline boxes each
+ * number passed to it, eleven here, once per hull-sphere pair, and the same goes for the rotations
+ * inside, so those take arrays too.
+ *
+ * @param {number[]|Float64Array} out length ≥ 10
+ * @param {ConvexHullShape3D} hull
+ * @param {Float64Array} pose
+ * @param {number} pose_offset
+ * @param {Float64Array} sphere
+ * @param {number} sphere_offset
+ * @returns {boolean} true if they overlap
+ */
+export function hull_sphere_contact_array(out, hull, pose, pose_offset, sphere, sphere_offset) {
+    const px = pose[pose_offset], py = pose[pose_offset + 1], pz = pose[pose_offset + 2];
+    const rotation = pose_offset + 3;
+    const sx = sphere[sphere_offset], sy = sphere[sphere_offset + 1], sz = sphere[sphere_offset + 2];
+    const radius = sphere[sphere_offset + 3];
+
+    scratch_centre[0] = sx - px;
+    scratch_centre[1] = sy - py;
+    scratch_centre[2] = sz - pz;
+    v3_quaternion_apply_inverse_array(scratch_centre, 0, scratch_centre, 0, pose, rotation);
+
+    const cx = scratch_centre[0];
+    const cy = scratch_centre[1];
+    const cz = scratch_centre[2];
+
+    // the face the centre is least behind (or furthest in front of) — one plane per flat side
+    const planes = hull.face_loop_planes;
+    const plane_count = planes.length / 4;
+
+    let best_separation = -Infinity;
+    let best = 0;
+
+    for (let f = 0; f < plane_count; f++) {
+        const o = f * 4;
+        const nx = planes[o], ny = planes[o + 1], nz = planes[o + 2];
+
+        // A face with no area has no plane — it is stored as zero, and its "separation" of 0 would
+        // beat every real face for a centre inside, leaving no normal at all.
+        if (nx * nx + ny * ny + nz * nz < 0.5) continue;
+
+        const s = nx * cx + ny * cy + nz * cz - planes[o + 3];
+
+        if (s > best_separation) {
+            best_separation = s;
+            best = f * 4;
+        }
+    }
+
+    if (best_separation > radius) {
+        // a whole face's half-space lies between them
+        return false;
+    }
+
+    let nx = 0, ny = 0, nz = 0, distance = 0;
+    let shallow = false;
+
+    if (best_separation > 0 && over_face(hull, best >> 2, scratch_centre, 0)) {
+        // Outside, over the face it is furthest in front of: nothing of the hull is nearer than that
+        // face's plane, and the foot of the perpendicular is on the face — the closest point. (The
+        // common case — resting on a side — so the O(F) surface scan below is not paid for it.)
+        nx = planes[best];
+        ny = planes[best + 1];
+        nz = planes[best + 2];
+        distance = best_separation;
+
+        scratch_closest[0] = cx - nx * best_separation;
+        scratch_closest[1] = cy - ny * best_separation;
+        scratch_closest[2] = cz - nz * best_separation;
+
+        shallow = distance > SHALLOW_DISTANCE;
+    } else if (best_separation > 0) {
+        // outside, off an edge or a corner: the closest surface point is the closest point of the hull
+        hull.nearest_point_on_surface(scratch_closest, scratch_centre);
+
+        const dx = cx - scratch_closest[0];
+        const dy = cy - scratch_closest[1];
+        const dz = cz - scratch_closest[2];
+
+        distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+        if (distance > radius) {
+            return false;
+        }
+
+        if (distance > SHALLOW_DISTANCE) {
+            const inv = 1 / distance;
+            nx = dx * inv;
+            ny = dy * inv;
+            nz = dz * inv;
+            shallow = true;
+        }
+    }
+
+    if (!shallow) {
+        // on or inside the surface: out through the nearest face
+        nx = planes[best];
+        ny = planes[best + 1];
+        nz = planes[best + 2];
+        distance = best_separation;
+
+        scratch_closest[0] = cx - nx * best_separation;
+        scratch_closest[1] = cy - ny * best_separation;
+        scratch_closest[2] = cz - nz * best_separation;
+    }
+
+    // back to the world
+    scratch_normal[0] = nx;
+    scratch_normal[1] = ny;
+    scratch_normal[2] = nz;
+    v3_quaternion_apply_array(scratch_world, 0, scratch_normal, 0, pose, rotation);
+    const wnx = scratch_world[0], wny = scratch_world[1], wnz = scratch_world[2];
+
+    v3_quaternion_apply_array(scratch_world, 0, scratch_closest, 0, pose, rotation);
+
+    out[0] = wnx;
+    out[1] = wny;
+    out[2] = wnz;
+    out[3] = radius - distance;
+    out[4] = sx - wnx * radius;
+    out[5] = sy - wny * radius;
+    out[6] = sz - wnz * radius;
+    out[7] = scratch_world[0] + px;
+    out[8] = scratch_world[1] + py;
+    out[9] = scratch_world[2] + pz;
+
+    return true;
+}
+
+/**
+ * Whether a point in front of a polygon face lies over it: inside every one of its edges' planes
+ * perpendicular to the face. The loop is convex and wound CCW seen from outside, so `(b − a) × n`
+ * points out of the polygon at each edge `a → b`.
+ *
+ * @param {ConvexHullShape3D} hull
+ * @param {number} face
+ * @param {Float64Array} point hull-local point, read from an array: this is not always inlined, and a
+ *   call that is not boxes the numbers it takes
+ * @param {number} point_offset
+ * @returns {boolean}
+ */
+function over_face(hull, face, point, point_offset) {
+    const x = point[point_offset], y = point[point_offset + 1], z = point[point_offset + 2];
+    const v = hull.vertices;
+    const fl = hull.face_loops;
+    const s = hull.face_offsets[face], e = hull.face_offsets[face + 1];
+
+    const planes = hull.face_loop_planes;
+    const nx = planes[face * 4], ny = planes[face * 4 + 1], nz = planes[face * 4 + 2];
+
+    for (let i = s; i < e; i++) {
+        const a = fl[i] * 3, b = fl[i + 1 < e ? i + 1 : s] * 3;
+
+        const ex = v[b] - v[a], ey = v[b + 1] - v[a + 1], ez = v[b + 2] - v[a + 2];
+        const ox = ey * nz - ez * ny, oy = ez * nx - ex * nz, oz = ex * ny - ey * nx;
+
+        if ((x - v[a]) * ox + (y - v[a + 1]) * oy + (z - v[a + 2]) * oz > 0) {
+            return false;
+        }
+    }
+
+    return true;
+}

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

@@ -97,7 +97,11 @@ function build_if_convex(meshShape) {
     const piece = build_piece(tp, boundary);
     const v = piece.vertices;
     const vc = v.length / 3;
-    piece.support = function (result, result_offset, dx, dy, dz) {
+    piece.support = function (result, result_offset, direction, direction_offset) {
+        const dx = direction[direction_offset];
+        const dy = direction[direction_offset + 1];
+        const dz = direction[direction_offset + 2];
+
         let bi = 0, best = -Infinity;
         for (let i = 0; i < vc; i++) {
             const d = v3_dot(dx, dy, dz, v[i * 3], v[i * 3 + 1], v[i * 3 + 2]);

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

@@ -1,6 +1,8 @@
 /**
  * Append the mesh-vs-mesh contacts via `append`, the narrowphase's
  * `append_contact(count, wax,way,waz, wbx,wby,wbz, nx,ny,nz, depth, fid) → newCount`.
+ * Every overlapping piece pair's contacts are appended — the candidate buffer
+ * grows, and the manifold reduction downstream picks from all of them.
  *
  * @returns {number} new candidate count
  */

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

@@ -1 +1 @@
-{"version":3,"file":"mesh_mesh_tet_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/mesh_mesh_tet_manifold.js"],"names":[],"mappings":"AAkDA;;;;;GAKG;AACH,+GAFa,MAAM,CA8DlB"}
+{"version":3,"file":"mesh_mesh_tet_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/mesh_mesh_tet_manifold.js"],"names":[],"mappings":"AA+DA;;;;;;;GAOG;AACH,+GAFa,MAAM,CAwElB"}

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

@@ -1,6 +1,6 @@
 import { bvh_query_user_data_intersects_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
-import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
-import { aabb3_transform_oriented_inverse } from "../../../core/geom/3d/aabb/aabb3_transform_oriented_inverse.js";
+import { aabb3_transform_oriented_array } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
+import { aabb3_transform_oriented_inverse_array } from "../../../core/geom/3d/aabb/aabb3_transform_oriented_inverse.js";
 import { build_convex_decomposition } from "./convex_decomposition.js";
 import { convex_convex_manifold, CONVEX_CONVEX_OUT_LENGTH } from "./convex_convex_manifold.js";
 
@@ -25,10 +25,6 @@ import { convex_convex_manifold, CONVEX_CONVEX_OUT_LENGTH } from "./convex_conve
  * @copyright Company Named Limited (c) 2026
  */
 
-/** Stop emitting once the candidate buffer is nearly full (capped at 4
- *  downstream); a localised resting contact never approaches this. */
-const MAX_EMIT = 60;
-
 const piece_out = new Float64Array(CONVEX_CONVEX_OUT_LENGTH);
 let cand_a = new Uint32Array(4096);
 let cand_b = new Uint32Array(4096);
@@ -36,6 +32,23 @@ const local_bbox = new Float64Array(6);
 const world_aabb = new Float64Array(6);
 const query_aabb = new Float64Array(6);
 
+/**
+ * The two poses as the arrays {@link convex_convex_manifold} takes, copied out of the transforms once
+ * per pair: reading a Transform64's `translation` or `rotation` builds a fresh view on every read, and
+ * this ran four of them per piece pair.
+ */
+const position_a = new Float64Array(3);
+const rotation_a = new Float64Array(4);
+const position_b = new Float64Array(3);
+const rotation_b = new Float64Array(4);
+
+/**
+ * The same poses packed `[px, py, pz, qx, qy, qz, qw]` for the AABB transforms' array forms: handed
+ * to them as seven numbers (they are not inlined here), each would be boxed, per piece of A.
+ */
+const pose_a = new Float64Array(7);
+const pose_b = new Float64Array(7);
+
 /** Build + cache the convex decomposition on the (immutable, shared) shape. */
 function get_decomposition(shape) {
     let d = shape.__convex_decomposition;
@@ -51,6 +64,8 @@ function ensure(buf, n) { return buf.length >= n ? buf : new Uint32Array(n); }
 /**
  * Append the mesh-vs-mesh contacts via `append`, the narrowphase's
  * `append_contact(count, wax,way,waz, wbx,wby,wbz, nx,ny,nz, depth, fid) → newCount`.
+ * Every overlapping piece pair's contacts are appended — the candidate buffer
+ * grows, and the manifold reduction downstream picks from all of them.
  *
  * @returns {number} new candidate count
  */
@@ -60,19 +75,31 @@ export function mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append)
     const piecesA = decompA.pieces;
     const piecesB = decompB.pieces;
 
+    position_a[0] = trA.translation_x;
+    position_a[1] = trA.translation_y;
+    position_a[2] = trA.translation_z;
+    rotation_a[0] = trA.rotation_x;
+    rotation_a[1] = trA.rotation_y;
+    rotation_a[2] = trA.rotation_z;
+    rotation_a[3] = trA.rotation_w;
+
+    position_b[0] = trB.translation_x;
+    position_b[1] = trB.translation_y;
+    position_b[2] = trB.translation_z;
+    rotation_b[0] = trB.rotation_x;
+    rotation_b[1] = trB.rotation_y;
+    rotation_b[2] = trB.rotation_z;
+    rotation_b[3] = trB.rotation_w;
+
+    pose_a[0] = position_a[0]; pose_a[1] = position_a[1]; pose_a[2] = position_a[2];
+    pose_a[3] = rotation_a[0]; pose_a[4] = rotation_a[1]; pose_a[5] = rotation_a[2]; pose_a[6] = rotation_a[3];
+    pose_b[0] = position_b[0]; pose_b[1] = position_b[1]; pose_b[2] = position_b[2];
+    pose_b[3] = rotation_b[0]; pose_b[4] = rotation_b[1]; pose_b[5] = rotation_b[2]; pose_b[6] = rotation_b[3];
+
     // Candidate pieces of A: those whose AABB overlaps B's world AABB (in A-local).
     shapeB.compute_bounding_box(local_bbox);
-    aabb3_transform_oriented(
-        world_aabb, 0,
-        local_bbox[0], local_bbox[1], local_bbox[2], local_bbox[3], local_bbox[4], local_bbox[5],
-        trB.translation_x, trB.translation_y, trB.translation_z,
-        trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w
-    );
-    aabb3_transform_oriented_inverse(
-        query_aabb, 0, world_aabb,
-        trA.translation_x, trA.translation_y, trA.translation_z,
-        trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w
-    );
+    aabb3_transform_oriented_array(world_aabb, 0, local_bbox, 0, pose_b, 0);
+    aabb3_transform_oriented_inverse_array(query_aabb, 0, world_aabb, pose_a, 0);
 
     cand_a = ensure(cand_a, piecesA.length);
     const nA = bvh_query_user_data_intersects_aabb(cand_a, 0, decompA.bvh, query_aabb);
@@ -81,24 +108,23 @@ export function mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append)
         const pieceA = piecesA[cand_a[i]];
 
         // Candidate pieces of B near this piece of A.
-        const ab = pieceA.aabb;
-        aabb3_transform_oriented(
-            world_aabb, 0,
-            ab[0], ab[1], ab[2], ab[3], ab[4], ab[5],
-            trA.translation_x, trA.translation_y, trA.translation_z,
-            trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w
-        );
-        aabb3_transform_oriented_inverse(
-            query_aabb, 0, world_aabb,
-            trB.translation_x, trB.translation_y, trB.translation_z,
-            trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w
-        );
+        aabb3_transform_oriented_array(world_aabb, 0, pieceA.aabb, 0, pose_a, 0);
+        aabb3_transform_oriented_inverse_array(query_aabb, 0, world_aabb, pose_b, 0);
         cand_b = ensure(cand_b, piecesB.length);
         const nB = bvh_query_user_data_intersects_aabb(cand_b, 0, decompB.bvh, query_aabb);
 
+        // Every piece pair the box query admits runs the full SAT + clip: there is no stopping
+        // once "enough" contacts are in, because that cap dropped contacts by piece order. It is
+        // the cost of a mesh-vs-mesh pair — on a pile of 12 "waffles" (3 x 3 posts each) on a
+        // 16 x 16 tile floor, +54% a step over the old cap of 60 (22.4 -> 34.5 ms), 72% of the
+        // step in convex_convex_manifold's SAT. Over 48 poses of that pile the SAT ran 65,836
+        // times and kept 28,710. A world-box test on the pair before it (the query above carries
+        // A's box into B's frame, which loosens it) would have skipped 8,584 (13%), none of which
+        // the SAT kept there — but it is not exact in general: the SAT skips degenerate axes
+        // (sliver faces, near-parallel edge pairs), so a pair it keeps could have disjoint boxes.
         for (let j = 0; j < nB; j++) {
             const pieceB = piecesB[cand_b[j]];
-            if (!convex_convex_manifold(piece_out, pieceA, trA.translation, trA.rotation, pieceB, trB.translation, trB.rotation)) {
+            if (!convex_convex_manifold(piece_out, pieceA, position_a, rotation_a, pieceB, position_b, rotation_b)) {
                 continue;
             }
             const cc = piece_out[3] | 0;
@@ -110,7 +136,6 @@ export function mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append)
                     piece_out[base + 3], piece_out[base + 4], piece_out[base + 5],
                     nx, ny, nz, piece_out[base + 6], 0);
             }
-            if (count >= MAX_EMIT) return count;
         }
     }
     return count;

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

@@ -22,8 +22,9 @@
  * step (depenetration, overlap depth, tooling) — never from inside one.
  *
  * Both poses are read BY INDEX on the way into the stand-in `Transform64`s —
- * a `Transform64`'s own `translation` / `rotation` (`Float64Array` views), a
- * `Vector3` / `Quaternion` (both `Float64Array` subclasses) and plain
+ * a retained `Float64Array` (not a Transform64's `translation` / `rotation`,
+ * which allocate a view per read), a `Vector3` / `Quaternion` (both
+ * `Float64Array` subclasses) and plain
  * `[x, y, z]` / `[x, y, z, w]` arrays all work; an `{x, y, z, w}` object does
  * not. Its components read as `undefined`, which trips `setTranslation`'s
  * `assert.isNumber` in development and, with `assert.*` stripped from a
@@ -75,9 +76,9 @@ export function narrowphase_step(pair_list: PairList, manifolds: ManifoldStore,
  *
  * Matching is by feature id (stable per-triangle for the decomposition path),
  * so a contact's geometry tracks the same triangle across substeps. A contact
- * whose triangle isn't found this substep keeps its previous geometry (a rare
- * transient; the once-per-frame {@link narrowphase_step} re-establishes the
- * contact set next outer step). Count never changes here, so the solver's
+ * whose triangle isn't found this substep keeps its previous geometry, moved by
+ * how far the found contacts moved (a transient; the once-per-frame
+ * {@link narrowphase_step} re-establishes the contact set next outer step). Count never changes here, so the solver's
  * per-contact scratch (sized once at prepare) stays aligned.
  *
  * @param {ManifoldStore} manifolds

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

@@ -1 +1 @@
-{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAg5CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qDAZW,YAAY,GAAC,MAAM,EAAE,iCAGrB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,iCAGjB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,GAEf,MAAM,CA2ClB;AAED;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,CAAC,QA6LpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,UACnD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,QA2H7D;4BA7xD2B,oCAAoC"}
+{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAu2FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qDAZW,YAAY,GAAC,MAAM,EAAE,iCAGrB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,iCAGjB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,GAEf,MAAM,CA2ClB;AA2JD;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,CAAC,QAmMpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,UACnD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,QA0K7D;4BA16GM,oCAAoC"}