@woosh/meep-engine 3.37.0 → 3.39.0

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

@@ -197,11 +197,15 @@ function get_sat_edges(shape) {
  * taken from the SAT scan. Mirrors Bullet's "face most opposing the normal", made symmetric across A and B.
  *
  * @param {boolean} is_A select within piece A, otherwise piece B
- * @param {number} mx  axis toward the other body, x
- * @param {number} my  axis toward the other body, y
- * @param {number} mz  axis toward the other body, z
+ * @param {Float64Array} n  the contact normal `n` (B→A), whose negation is A's axis toward B. Read
+ *   from an array: this is called where V8 will not inline it, and a call boxes the numbers it takes
+ * @param {number} n_offset
  */
-function select_reference_face(is_A, mx, my, mz) {
+function select_reference_face(is_A, n, n_offset) {
+    const mx = is_A ? -n[n_offset] : n[n_offset];
+    const my = is_A ? -n[n_offset + 1] : n[n_offset + 1];
+    const mz = is_A ? -n[n_offset + 2] : n[n_offset + 2];
+
     const nf = is_A ? g_fA : g_fB;
     const wv = is_A ? wvA : wvB;
     const fl = is_A ? g_flA : g_flB;
@@ -226,21 +230,28 @@ function select_reference_face(is_A, mx, my, mz) {
     ref_sel.score = best;
 }
 
+/**
+ * The candidate axis handed to {@link test_axis}: x, y, z, then ref². In an array because test_axis
+ * is too big for V8 to inline, and a call that is not inlined boxes each number passed to it — four
+ * per axis, over every face and edge pair of every pair of pieces.
+ */
+const sat_axis = new Float64Array(4);
+
 /**
  * SAT axis test; true if the axis SEPARATES the pieces.
- * @param {number} ux candidate axis x; need not be unit (normalised here)
- * @param {number} uy candidate axis y
- * @param {number} uz candidate axis z
+ * @param {Float64Array} axis the candidate axis `[x, y, z, ref2]`. The axis need not be unit
+ *   (normalised here). ref2 is the square of the axis's characteristic magnitude (Σ|edge|² for a
+ *   face, |ea|²·|eb|² for an edge cross); the axis is rejected as degenerate when `len2 / ref2` — a
+ *   scale-invariant fatness / sin²θ — falls below {@link PARALLEL_EPS_REL}. See PARALLEL_EPS_REL.
  * @param {number} nA vertex count of piece A in {@link wvA}
  * @param {number} nB vertex count of piece B in {@link wvB}
  * @param {number} kind axis provenance recorded on a new minimum: 0 = A face normal,
  *   1 = B face normal, 2 = edge × edge cross
- * @param {number} ref2 square of the axis's characteristic magnitude (Σ|edge|² for a face,
- *   |ea|²·|eb|² for an edge cross); the axis is rejected as degenerate when `len2 / ref2` — a
- *   scale-invariant fatness / sin²θ — falls below {@link PARALLEL_EPS_REL}. See PARALLEL_EPS_REL.
  * @returns {boolean} true if this axis separates the pieces
  */
-function test_axis(ux, uy, uz, nA, nB, kind, ref2) {
+function test_axis(axis, nA, nB, kind) {
+    let ux = axis[0], uy = axis[1], uz = axis[2];
+    const ref2 = axis[3];
     const len2 = ux * ux + uy * uy + uz * uz;
     if (len2 < PARALLEL_EPS_REL * ref2) return false;
     const inv = 1 / Math.sqrt(len2);
@@ -262,7 +273,9 @@ function test_axis(ux, uy, uz, nA, nB, kind, ref2) {
     if (sat.kind === -1 || overlap < sat.overlap - (sat.overlap * TIE_REL + TIE_ABS)) {
         sat.overlap = overlap;
         const dcx = cenA[0] - cenB[0], dcy = cenA[1] - cenB[1], dcz = cenA[2] - cenB[2];
-        const sign = v3_dot(ux, uy, uz, dcx, dcy, dcz) >= 0 ? 1 : -1;
+        // Written out rather than a call to v3_dot: this branch is taken on too few of the calls for
+        // V8 to inline a call in it, and a call that is not inlined boxes each of its six numbers.
+        const sign = (ux * dcx + uy * dcy + uz * dcz) >= 0 ? 1 : -1;
         sat.nx = ux * sign; sat.ny = uy * sign; sat.nz = uz * sign;
         sat.kind = kind;
     }
@@ -292,15 +305,19 @@ export function convex_convex_manifold(out, A, posA, rotA, B, posB, rotB) {
 
     sat.kind = -1; sat.overlap = Infinity;
 
+    const axis = sat_axis;
+
     // A face normals.
     for (let f = 0; f < g_fA; f++) {
-        const s2 = face_normal(tmp_n, wvA, g_flA, g_foA[f], g_foA[f + 1]);
-        if (test_axis(tmp_n[0], tmp_n[1], tmp_n[2], g_nA, g_nB, 0, s2 * s2)) return false;
+        const s2 = face_normal(axis, wvA, g_flA, g_foA[f], g_foA[f + 1]);
+        axis[3] = s2 * s2;
+        if (test_axis(axis, g_nA, g_nB, 0)) return false;
     }
     // B face normals.
     for (let f = 0; f < g_fB; f++) {
-        const s2 = face_normal(tmp_n, wvB, g_flB, g_foB[f], g_foB[f + 1]);
-        if (test_axis(tmp_n[0], tmp_n[1], tmp_n[2], g_nA, g_nB, 1, s2 * s2)) return false;
+        const s2 = face_normal(axis, wvB, g_flB, g_foB[f], g_foB[f + 1]);
+        axis[3] = s2 * s2;
+        if (test_axis(axis, g_nA, g_nB, 1)) return false;
     }
     // Edge × edge crosses, over each hull's UNIQUE edges (cached per shape —
     // see get_sat_edges; the face-loop scan retested every interior edge pair
@@ -316,9 +333,12 @@ export function convex_convex_manifold(out, A, posA, rotA, B, posB, rotB) {
         for (let ib = 0; ib < neB; ib += 2) {
             const b0 = edgesB[ib] * 3, b1 = edgesB[ib + 1] * 3;
             const ebx = wvB[b1] - wvB[b0], eby = wvB[b1 + 1] - wvB[b0 + 1], ebz = wvB[b1 + 2] - wvB[b0 + 2];
-            const cx = eay * ebz - eaz * eby, cy = eaz * ebx - eax * ebz, cz = eax * eby - eay * ebx;
+            axis[0] = eay * ebz - eaz * eby;
+            axis[1] = eaz * ebx - eax * ebz;
+            axis[2] = eax * eby - eay * ebx;
             // ref² = |ea|²·|eb|² makes len²/ref² = sin²θ, a true (scale-invariant) parallelism test.
-            if (test_axis(cx, cy, cz, g_nA, g_nB, 2, ea2 * (ebx * ebx + eby * eby + ebz * ebz))) return false;
+            axis[3] = ea2 * (ebx * ebx + eby * eby + ebz * ebz);
+            if (test_axis(axis, g_nA, g_nB, 2)) return false;
         }
     }
 
@@ -336,14 +356,9 @@ export function convex_convex_manifold(out, A, posA, rotA, B, posB, rotB) {
     // Face winner: reference / incident polygon clipping. SAT decided WHICH piece owns the
     // reference face, but not which of its two antipodal faces — see select_reference_face.
     const ref_is_A = sat.kind === 0;
-    select_reference_face(
-        ref_is_A,
-        ref_is_A ? -nx : nx,
-        ref_is_A ? -ny : ny,
-        ref_is_A ? -nz : nz
-    );
+    select_reference_face(ref_is_A, out, 0);
 
-    emit_face_manifold(out, ref_is_A, ref_sel.face, nx, ny, nz);
+    emit_face_manifold(out, ref_is_A, ref_sel.face);
     return true;
 }
 
@@ -372,6 +387,36 @@ export function convex_convex_manifold(out, A, posA, rotA, B, posB, rotB) {
  * @returns {boolean} always true
  */
 export function convex_hull_clip(out, A, posA, rotA, B, posB, rotB, nx, ny, nz) {
+    const axis = scratch_clip_axis;
+
+    axis[0] = nx;
+    axis[1] = ny;
+    axis[2] = nz;
+
+    return convex_hull_clip_array(out, A, posA, rotA, B, posB, rotB, axis, 0);
+}
+
+/** Where {@link convex_hull_clip} packs its axis. */
+const scratch_clip_axis = new Float64Array(3);
+
+/**
+ * {@link convex_hull_clip} with the axis read from `axis[axis_offset ..+2]`: the hull-pair contact
+ * routine does not inline the call, and handed the axis as three numbers it boxed each.
+ *
+ * @param {Float64Array|number[]} out length ≥ CONVEX_CONVEX_OUT_LENGTH
+ * @param {{vertices,face_offsets,face_loops}} A
+ * @param {{x,y,z}} posA
+ * @param {{x,y,z,w}} rotA
+ * @param {{vertices,face_offsets,face_loops}} B
+ * @param {{x,y,z}} posB
+ * @param {{x,y,z,w}} rotB
+ * @param {Float64Array} axis unit axis as returned by {@link gjk_epa_penetration}, either sign
+ * @param {number} axis_offset
+ * @returns {boolean} always true
+ */
+export function convex_hull_clip_array(out, A, posA, rotA, B, posB, rotB, axis, axis_offset) {
+    let nx = axis[axis_offset], ny = axis[axis_offset + 1], nz = axis[axis_offset + 2];
+
     set_geom(A, B);
     load_world(wvA, A.vertices, g_nA, posA, rotA);
     load_world(wvB, B.vertices, g_nB, posB, rotB);
@@ -392,16 +437,16 @@ export function convex_hull_clip(out, A, posA, rotA, B, posB, rotB, nx, ny, nz)
     // with the axis pointing toward the other body. A's contact face points
     // toward B (along −n); B's toward A (along +n). The flatter (better-aligned)
     // one is the reference.
-    select_reference_face(true, -nx, -ny, -nz);
+    select_reference_face(true, out, 0);
     const bestA = ref_sel.score;
     const faceA = ref_sel.face;
 
-    select_reference_face(false, nx, ny, nz);
+    select_reference_face(false, out, 0);
     const bestB = ref_sel.score;
     const faceB = ref_sel.face;
 
     const ref_is_A = bestA >= bestB;
-    emit_face_manifold(out, ref_is_A, ref_is_A ? faceA : faceB, nx, ny, nz);
+    emit_face_manifold(out, ref_is_A, ref_is_A ? faceA : faceB);
 
     if ((out[3] | 0) === 0) {
         const overlap = projection_overlap(nx, ny, nz);
@@ -424,22 +469,123 @@ function projection_overlap(nx, ny, nz) {
     return maxB - minA;
 }
 
-/** Single deepest support-pair contact along axis `n` (B→A). */
-function emit_single_contact(out, nx, ny, nz, depth) {
-    let sa = -Infinity, ai = 0;
-    for (let i = 0; i < g_nA; i++) {
-        const d = -v3_dot(nx, ny, nz, wvA[i * 3], wvA[i * 3 + 1], wvA[i * 3 + 2]);
-        if (d > sa) { sa = d; ai = i; }
+/**
+ * Vertices within this fraction of a piece's extent along the axis of its extreme projection count
+ * as one support feature (a face or an edge lying across the axis), not as a vertex.
+ * @type {number}
+ */
+const SUPPORT_TIE_REL = 1e-3;
+
+/**
+ * Support-feature records written by {@link support_feature}:
+ *   0 vertex count, 1..3 centroid, 4 squared spread (largest squared distance of a member from the
+ *   centroid), 5..6 world-vertex offsets of the first two members, 7 the extreme projection.
+ */
+const feature_A = new Float64Array(8);
+const feature_B = new Float64Array(8);
+
+/**
+ * The support feature of a piece along `d`: every vertex whose projection on `d` is within
+ * {@link SUPPORT_TIE_REL} of the piece's extent of the extreme one.
+ *
+ * @param {Float64Array} out a feature record (see {@link feature_A})
+ * @param {Float64Array} wv world vertices
+ * @param {number} n vertex count
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ */
+function support_feature(out, wv, n, dx, dy, dz) {
+    let hi = -Infinity, lo = Infinity;
+    for (let i = 0; i < n; i++) {
+        const d = v3_dot(dx, dy, dz, wv[i * 3], wv[i * 3 + 1], wv[i * 3 + 2]);
+        if (d > hi) hi = d;
+        if (d < lo) lo = d;
     }
-    let sb = -Infinity, bi = 0;
-    for (let i = 0; i < g_nB; i++) {
-        const d = v3_dot(nx, ny, nz, wvB[i * 3], wvB[i * 3 + 1], wvB[i * 3 + 2]);
-        if (d > sb) { sb = d; bi = i; }
+    const floor = hi - (hi - lo) * SUPPORT_TIE_REL;
+
+    let count = 0, cx = 0, cy = 0, cz = 0;
+    out[5] = out[6] = -1;
+    for (let i = 0; i < n; i++) {
+        const o = i * 3;
+        if (v3_dot(dx, dy, dz, wv[o], wv[o + 1], wv[o + 2]) < floor) continue;
+        if (count < 2) out[5 + count] = o;
+        cx += wv[o]; cy += wv[o + 1]; cz += wv[o + 2];
+        count++;
+    }
+    cx /= count; cy /= count; cz /= count;
+
+    let spread = 0;
+    for (let i = 0; i < n; i++) {
+        const o = i * 3;
+        if (v3_dot(dx, dy, dz, wv[o], wv[o + 1], wv[o + 2]) < floor) continue;
+        const ex = wv[o] - cx, ey = wv[o + 1] - cy, ez = wv[o + 2] - cz;
+        const s = ex * ex + ey * ey + ez * ez;
+        if (s > spread) spread = s;
     }
+
+    out[0] = count;
+    out[1] = cx; out[2] = cy; out[3] = cz;
+    out[4] = spread;
+    out[7] = hi;
+}
+
+/**
+ * Single contact along axis `n` (B→A) for a penetrating pair whose face clip left nothing.
+ *
+ * It belongs where the two pieces touch, and the solver acts at the witnesses' midpoint, so a raw
+ * support vertex of each piece will not do: the support of a large flat side along its own normal
+ * is a tie between its corners, and the first corner of a 40 m floor is 28 m from a cube sitting on
+ * it. A hull cube resting on the half of a two-triangle floor side that was not the reference face
+ * got exactly that, and the torque about the far corner tipped it through the floor.
+ *
+ * Instead, take each piece's support feature facing the other, and use the SMALLER one, which lies
+ * inside the contact: its centroid is one witness, and its projection along `n` onto the other
+ * piece's support plane is the other — a body's whole bottom face over a floor gives the point under
+ * its middle. Two edges crossing meet at their closest points, as the SAT path's edge contact does.
+ */
+function emit_single_contact(out, nx, ny, nz, depth) {
+    // A's feature faces B: extreme along −n; B's faces A: extreme along +n. (n is B → A.)
+    support_feature(feature_A, wvA, g_nA, -nx, -ny, -nz);
+    support_feature(feature_B, wvB, g_nB, nx, ny, nz);
+
     out[3] = 1;
-    out[4] = wvA[ai * 3]; out[5] = wvA[ai * 3 + 1]; out[6] = wvA[ai * 3 + 2];
-    out[7] = wvB[bi * 3]; out[8] = wvB[bi * 3 + 1]; out[9] = wvB[bi * 3 + 2];
     out[10] = depth;
+
+    if (feature_A[0] === 2 && feature_B[0] === 2) {
+        const a0 = feature_A[5], a1 = feature_A[6];
+        const b0 = feature_B[5], b1 = feature_B[6];
+
+        line3_compute_segment_segment_closest_points(
+            scratch_st,
+            wvA[a0], wvA[a0 + 1], wvA[a0 + 2],
+            wvA[a1], wvA[a1 + 1], wvA[a1 + 2],
+            wvB[b0], wvB[b0 + 1], wvB[b0 + 2],
+            wvB[b1], wvB[b1 + 1], wvB[b1 + 2]
+        );
+        const s = scratch_st[0];
+        const t = scratch_st[1];
+        out[4] = wvA[a0]     + (wvA[a1]     - wvA[a0])     * s;
+        out[5] = wvA[a0 + 1] + (wvA[a1 + 1] - wvA[a0 + 1]) * s;
+        out[6] = wvA[a0 + 2] + (wvA[a1 + 2] - wvA[a0 + 2]) * s;
+        out[7] = wvB[b0]     + (wvB[b1]     - wvB[b0])     * t;
+        out[8] = wvB[b0 + 1] + (wvB[b1 + 1] - wvB[b0 + 1]) * t;
+        out[9] = wvB[b0 + 2] + (wvB[b1 + 2] - wvB[b0 + 2]) * t;
+        return;
+    }
+
+    // n · x on A's support plane is −feature_A[7]; on B's it is feature_B[7]
+    if (feature_A[4] <= feature_B[4]) {
+        const cx = feature_A[1], cy = feature_A[2], cz = feature_A[3];
+        const k = feature_B[7] - v3_dot(nx, ny, nz, cx, cy, cz);
+        out[4] = cx; out[5] = cy; out[6] = cz;
+        out[7] = cx + nx * k; out[8] = cy + ny * k; out[9] = cz + nz * k;
+    } else {
+        const cx = feature_B[1], cy = feature_B[2], cz = feature_B[3];
+        const k = -feature_A[7] - v3_dot(nx, ny, nz, cx, cy, cz);
+        out[4] = cx + nx * k; out[5] = cy + ny * k; out[6] = cz + nz * k;
+        out[7] = cx; out[8] = cy; out[9] = cz;
+    }
 }
 
 const scratch_st = new Float64Array(2);
@@ -519,17 +665,16 @@ function emit_edge_pair_contact(out, nx, ny, nz, depth) {
 
 /**
  * Reference/incident polygon clipping given the reference face. Writes the
- * manifold (count + contacts) into `out`; leaves out[0..2] (the normal) as set
- * by the caller. Shared by both the SAT and GJK+EPA entry points.
+ * manifold (count + contacts) into `out`; reads the unit axis `n` (B→A) from
+ * out[0..2], where the caller set it, and leaves it there. Shared by both the
+ * SAT and GJK+EPA entry points.
  *
  * @param {Float64Array|number[]} out length ≥ CONVEX_CONVEX_OUT_LENGTH
  * @param {boolean} ref_is_A  reference face belongs to A (else B)
  * @param {number} ref_face   reference face index within its piece
- * @param {number} nx  axis (B→A) x, unit
- * @param {number} ny  axis (B→A) y, unit
- * @param {number} nz  axis (B→A) z, unit
  */
-function emit_face_manifold(out, ref_is_A, ref_face, nx, ny, nz) {
+function emit_face_manifold(out, ref_is_A, ref_face) {
+    const nx = out[0], ny = out[1], nz = out[2];
     const ref_wv = ref_is_A ? wvA : wvB;
     const ref_fo = ref_is_A ? g_foA : g_foB;
     const ref_fl = ref_is_A ? g_flA : g_flB;
@@ -588,7 +733,10 @@ function emit_face_manifold(out, ref_is_A, ref_face, nx, ny, nz) {
         let sx = edy * rmz - edz * rmy, sy = edz * rmx - edx * rmz, sz = edx * rmy - edy * rmx;
         const pax = ref_wv[va], pay = ref_wv[va + 1], paz = ref_wv[va + 2];
         if ((rcx - pax) * sx + (rcy - pay) * sy + (rcz - paz) * sz > 0) { sx = -sx; sy = -sy; sz = -sz; }
-        n_poly = clip_poly(src, n_poly, dst, sx, sy, sz, pax, pay, paz);
+        const plane = clip_plane;
+        plane[0] = sx; plane[1] = sy; plane[2] = sz;
+        plane[3] = pax; plane[4] = pay; plane[5] = paz;
+        n_poly = clip_poly_array(src, n_poly, dst, plane, 0);
         const t = src; src = dst; dst = t;
     }
     if (n_poly === 0) { out[3] = 0; return; }
@@ -628,8 +776,55 @@ function emit_face_manifold(out, ref_is_A, ref_face, nx, ny, nz) {
  * or the dropped OOB writes leave stale/NaN points that later reads consume
  * (the buffers are pre-sized to inc_len + ref_len, so the guard is a backstop
  * for degenerate input, not the normal bound).
+ *
+ * Shared with {@link feature_manifold}, which clips support features the same way.
+ *
+ * @param {Float64Array} src polygon, flat `(x, y, z)` per point
+ * @param {number} n point count in `src`
+ * @param {Float64Array} dst receives the clipped polygon; `src` and `dst` must not overlap
+ * @param {number} sx clip plane normal x (points with positive side are cut)
+ * @param {number} sy
+ * @param {number} sz
+ * @param {number} ax a point on the clip plane, x
+ * @param {number} ay
+ * @param {number} az
+ * @returns {number} point count written to `dst`
+ */
+export function clip_poly(src, n, dst, sx, sy, sz, ax, ay, az) {
+    const plane = clip_poly_plane;
+
+    plane[0] = sx;
+    plane[1] = sy;
+    plane[2] = sz;
+    plane[3] = ax;
+    plane[4] = ay;
+    plane[5] = az;
+
+    return clip_poly_array(src, n, dst, plane, 0);
+}
+
+/** Where {@link clip_poly} packs its plane. */
+const clip_poly_plane = new Float64Array(6);
+
+/** The side plane {@link emit_face_manifold} hands {@link clip_poly_array}. */
+const clip_plane = new Float64Array(6);
+
+/**
+ * {@link clip_poly} with the plane read from `plane[plane_offset ..+5]`: the normal `s`, then a point
+ * `a` on the plane. For a caller that cannot have the call inlined, where passing the plane's six
+ * numbers would box each into a new heap object, once per side plane of every face clip.
+ *
+ * @param {Float64Array} src polygon, flat `(x, y, z)` per point
+ * @param {number} n point count in `src`
+ * @param {Float64Array} dst receives the clipped polygon; `src` and `dst` must not overlap
+ * @param {Float64Array} plane `[sx, sy, sz, ax, ay, az]`
+ * @param {number} plane_offset
+ * @returns {number} point count written to `dst`
  */
-function clip_poly(src, n, dst, sx, sy, sz, ax, ay, az) {
+export function clip_poly_array(src, n, dst, plane, plane_offset) {
+    const sx = plane[plane_offset], sy = plane[plane_offset + 1], sz = plane[plane_offset + 2];
+    const ax = plane[plane_offset + 3], ay = plane[plane_offset + 4], az = plane[plane_offset + 5];
+
     const cap = (dst.length / 3) | 0;
     let m = 0;
     for (let i = 0; i < n && m < cap; i++) {

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

@@ -28,4 +28,17 @@
  * @returns {number} number of triangles written
  */
 export function decompose_to_triangles(output: Float64Array, offset: number, shape: AbstractShape3D, aabb_min_x: number, aabb_min_y: number, aabb_min_z: number, aabb_max_x: number, aabb_max_y: number, aabb_max_z: number): number;
+/**
+ * {@link decompose_to_triangles} with the query box read from `aabb[aabb_offset ..+5]`
+ * (`[min x, min y, min z, max x, max y, max z]`, the shape's body-local frame): the enumerators are
+ * past what V8 inlines, and a call that is not inlined boxes each number passed to it.
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {AbstractShape3D} shape (must have `is_convex === false`)
+ * @param {Float64Array} aabb
+ * @param {number} aabb_offset
+ * @returns {number} number of triangles written
+ */
+export function decompose_to_triangles_array(output: Float64Array, offset: number, shape: AbstractShape3D, aabb: Float64Array, aabb_offset: number): number;
 //# sourceMappingURL=decompose_to_triangles.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"decompose_to_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/decompose_to_triangles.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,+CAXW,YAAY,UACZ,MAAM,sCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAwBlB"}
+{"version":3,"file":"decompose_to_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/decompose_to_triangles.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,+CAXW,YAAY,UACZ,MAAM,sCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAalB;AAKD;;;;;;;;;;;GAWG;AACH,qDAPW,YAAY,UACZ,MAAM,gCAEN,YAAY,eACZ,MAAM,GACJ,MAAM,CAYlB"}

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

@@ -1,5 +1,5 @@
-import { heightmap_enumerate_triangles } from "./heightmap_enumerate_triangles.js";
-import { mesh_enumerate_triangles } from "./mesh_enumerate_triangles.js";
+import { heightmap_enumerate_triangles_array } from "./heightmap_enumerate_triangles.js";
+import { mesh_enumerate_triangles_array } from "./mesh_enumerate_triangles.js";
 
 /**
  * Dispatch a non-convex shape to its triangle enumerator. Writes
@@ -35,20 +35,36 @@ export function decompose_to_triangles(
     aabb_min_x, aabb_min_y, aabb_min_z,
     aabb_max_x, aabb_max_y, aabb_max_z
 ) {
+    const aabb = scratch_aabb;
+
+    aabb[0] = aabb_min_x; aabb[1] = aabb_min_y; aabb[2] = aabb_min_z;
+    aabb[3] = aabb_max_x; aabb[4] = aabb_max_y; aabb[5] = aabb_max_z;
+
+    return decompose_to_triangles_array(output, offset, shape, aabb, 0);
+}
+
+/** Where {@link decompose_to_triangles} packs its query box. */
+const scratch_aabb = new Float64Array(6);
+
+/**
+ * {@link decompose_to_triangles} with the query box read from `aabb[aabb_offset ..+5]`
+ * (`[min x, min y, min z, max x, max y, max z]`, the shape's body-local frame): the enumerators are
+ * past what V8 inlines, and a call that is not inlined boxes each number passed to it.
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {AbstractShape3D} shape (must have `is_convex === false`)
+ * @param {Float64Array} aabb
+ * @param {number} aabb_offset
+ * @returns {number} number of triangles written
+ */
+export function decompose_to_triangles_array(output, offset, shape, aabb, aabb_offset) {
     if (shape.isHeightMapShape3D === true) {
-        return heightmap_enumerate_triangles(
-            output, offset, shape,
-            aabb_min_x, aabb_min_y, aabb_min_z,
-            aabb_max_x, aabb_max_y, aabb_max_z
-        );
+        return heightmap_enumerate_triangles_array(output, offset, shape, aabb, aabb_offset);
     }
 
     if (shape.isMeshShape3D === true) {
-        return mesh_enumerate_triangles(
-            output, offset, shape,
-            aabb_min_x, aabb_min_y, aabb_min_z,
-            aabb_max_x, aabb_max_y, aabb_max_z
-        );
+        return mesh_enumerate_triangles_array(output, offset, shape, aabb, aabb_offset);
     }
 
     throw new Error(`decompose_to_triangles: no enumerator registered for shape kind \`${shape.constructor.name}\``);

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

@@ -61,4 +61,17 @@
  * @returns {number} number of triangles written
  */
 export function heightmap_enumerate_triangles(output: Float64Array, offset: number, shape: HeightMapShape3D, aabb_min_x: number, aabb_min_y: number, aabb_min_z: number, aabb_max_x: number, aabb_max_y: number, aabb_max_z: number): number;
+/**
+ * {@link heightmap_enumerate_triangles} with the query box read from `aabb[aabb_offset ..+5]`
+ * (`[min x, min y, min z, max x, max y, max z]`, the shape's body-local frame): this is past what V8
+ * inlines, and a call that is not inlined boxes each number passed to it.
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {HeightMapShape3D} shape
+ * @param {Float64Array} aabb
+ * @param {number} aabb_offset
+ * @returns {number} number of triangles written
+ */
+export function heightmap_enumerate_triangles_array(output: Float64Array, offset: number, shape: HeightMapShape3D, aabb: Float64Array, aabb_offset: number): number;
 //# sourceMappingURL=heightmap_enumerate_triangles.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"heightmap_enumerate_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/heightmap_enumerate_triangles.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,sDAXW,YAAY,UACZ,MAAM,uCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CA+MlB"}
+{"version":3,"file":"heightmap_enumerate_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/heightmap_enumerate_triangles.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,sDAXW,YAAY,UACZ,MAAM,uCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAalB;AAKD;;;;;;;;;;;GAWG;AACH,4DAPW,YAAY,UACZ,MAAM,iCAEN,YAAY,eACZ,MAAM,GACJ,MAAM,CA8MlB"}

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

@@ -88,6 +88,33 @@ export function heightmap_enumerate_triangles(
     aabb_min_x, aabb_min_y, aabb_min_z,
     aabb_max_x, aabb_max_y, aabb_max_z
 ) {
+    const aabb = scratch_aabb;
+
+    aabb[0] = aabb_min_x; aabb[1] = aabb_min_y; aabb[2] = aabb_min_z;
+    aabb[3] = aabb_max_x; aabb[4] = aabb_max_y; aabb[5] = aabb_max_z;
+
+    return heightmap_enumerate_triangles_array(output, offset, shape, aabb, 0);
+}
+
+/** Where {@link heightmap_enumerate_triangles} packs its query box. */
+const scratch_aabb = new Float64Array(6);
+
+/**
+ * {@link heightmap_enumerate_triangles} with the query box read from `aabb[aabb_offset ..+5]`
+ * (`[min x, min y, min z, max x, max y, max z]`, the shape's body-local frame): this is past what V8
+ * inlines, and a call that is not inlined boxes each number passed to it.
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {HeightMapShape3D} shape
+ * @param {Float64Array} aabb
+ * @param {number} aabb_offset
+ * @returns {number} number of triangles written
+ */
+export function heightmap_enumerate_triangles_array(output, offset, shape, aabb, aabb_offset) {
+    const aabb_min_x = aabb[aabb_offset], aabb_min_y = aabb[aabb_offset + 1], aabb_min_z = aabb[aabb_offset + 2];
+    const aabb_max_x = aabb[aabb_offset + 3], aabb_max_y = aabb[aabb_offset + 4], aabb_max_z = aabb[aabb_offset + 5];
+
     const sampler = shape.sampler;
 
     if (sampler === null) {

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

@@ -0,0 +1,42 @@
+/**
+ * {@link TriangleEdgeFlags} of the edges of one triangle {@link heightmap_enumerate_triangles} wrote into
+ * a triangle buffer (its corners: {@link heightmap_triangle_vertex_flat}): for each of its edges, whether the triangle across — the other half of its sub-cell across
+ * the diagonal, a neighbouring sub-cell's across a grid line — lies in its plane (FLAT), bends up
+ * (CONCAVE), or neither, a real edge; the rim of the footprint has no neighbour and is real. The
+ * classes are {@link tri3_classify_shared_edge}'s, as {@link MeshShape3D#get_triangle_edge_flags} gives
+ * a mesh.
+ *
+ * Nothing is stored. The triangle's own three corners are in the buffer; the far corner of each
+ * neighbour — three of them — is sampled exactly as the enumerator samples corners (the same
+ * Catmull-Rom filter, the same `i / seg_u`, `j / seg_v` products). A contact pays for this only on the
+ * triangles whose contacts the narrowphase has to judge, never per enumerated triangle.
+ *
+ * The edges are numbered as the enumerator winds the triangle: of `(A, D, B)`, A→D (the sub-cell's
+ * low-u side), D→B (the diagonal) and B→A (its low-v side); of `(D, C, B)`, D→C (high v), C→B
+ * (high u) and B→D (the diagonal).
+ *
+ * @param {HeightMapShape3D} shape
+ * @param {Float64Array} triangles a triangle buffer the enumerator wrote
+ * @param {number} offset float index of the triangle's entry
+ * @returns {number}
+ */
+export function heightmap_triangle_edge_flags(shape: HeightMapShape3D, triangles: Float64Array, offset: number): number;
+/**
+ * Whether corner `k` of one triangle {@link heightmap_enumerate_triangles} wrote into a triangle buffer
+ * is a FLAT vertex ({@link TriangleEdgeFlags.FlatVertexA} shifted by `k`): every one of the six edges
+ * meeting at that grid vertex is FLAT, the six triangles around it pairwise in one plane across each.
+ * A vertex on the rim of the footprint has rim edges, which are real, and is not.
+ *
+ * Corners are numbered as the enumerator winds the triangle: A, D, B of `(A, D, B)`; D, C, B of
+ * `(D, C, B)`. Nothing is stored: the six neighbours are sampled exactly as the enumerator samples
+ * corners, so a vertex has one answer from every triangle around it. Asked only for a corner a contact
+ * lies on.
+ *
+ * @param {HeightMapShape3D} shape
+ * @param {Float64Array} triangles a triangle buffer the enumerator wrote
+ * @param {number} offset float index of the triangle's entry
+ * @param {number} k corner, 0..2
+ * @returns {boolean}
+ */
+export function heightmap_triangle_vertex_flat(shape: HeightMapShape3D, triangles: Float64Array, offset: number, k: number): boolean;
+//# sourceMappingURL=heightmap_triangle_edge_flags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heightmap_triangle_edge_flags.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/heightmap_triangle_edge_flags.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,kFAJW,YAAY,UACZ,MAAM,GACJ,MAAM,CA2GlB;AAiBD;;;;;;;;;;;;;;;;GAgBG;AACH,mFALW,YAAY,UACZ,MAAM,KACN,MAAM,GACJ,OAAO,CAgEnB"}