@woosh/meep-engine 2.155.0 → 2.157.0

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

@@ -1,94 +1,97 @@
-import { TRIANGLE_FEATURE_ID_OFFSET, TRIANGLE_FLOAT_STRIDE } from "./triangle_buffer_layout.js";
-
-/**
- * Write the mesh's surface triangles that may overlap the given query
- * AABB into `output`, starting at float-index `offset`.
- *
- * Each triangle occupies {@link TRIANGLE_FLOAT_STRIDE} consecutive floats:
- *   [+0..+2]  vA.xyz   (shape's body-local frame, i.e. read directly from
- *                       {@link MeshShape3D#positions})
- *   [+3..+5]  vB.xyz
- *   [+6..+8]  vC.xyz
- *   [+9]      feature_id   (the surface triangle's index)
- *
- * Triangles are AABB-filtered: a triangle is emitted iff its tight AABB
- * (min/max across its 3 vertices) overlaps the query AABB. This is a
- * linear O(N) scan over the mesh's surface triangles — no surface-BVH
- * yet (the existing BVH on MeshShape3D is over the *tet* decomposition
- * used by `contains_point`, with different leaf semantics). For meshes
- * up to a few thousand triangles the linear scan is comfortably faster
- * than a BVH would be after broadphase has already given us a tight
- * query AABB; we can graduate to a per-mesh surface BVH later.
- *
- * Determinism: triangles are emitted in the natural index order, so
- * feature_id values inside `output` rise monotonically over a single
- * call. The narrowphase relies on this for stable contact-manifold
- * pairing across frames.
- *
- * Caller is responsible for ensuring
- *   `output.length - offset >= shape.indices.length / 3 * TRIANGLE_FLOAT_STRIDE`
- * in the worst case (every triangle overlaps).
- *
- * @param {Float64Array} output
- * @param {number} offset float-index into output
- * @param {MeshShape3D} shape
- * @param {number} aabb_min_x  query AABB in shape's body-local frame
- * @param {number} aabb_min_y
- * @param {number} aabb_min_z
- * @param {number} aabb_max_x
- * @param {number} aabb_max_y
- * @param {number} aabb_max_z
- * @returns {number} number of triangles written
- */
-export function mesh_enumerate_triangles(
-    output, offset, shape,
-    aabb_min_x, aabb_min_y, aabb_min_z,
-    aabb_max_x, aabb_max_y, aabb_max_z
-) {
-    const positions = shape.positions;
-    const indices = shape.indices;
-
-    const tri_count = (indices.length / 3) | 0;
-    if (tri_count === 0) {
-        return 0;
-    }
-
-    let count = 0;
-    let cursor = offset;
-
-    for (let t = 0; t < tri_count; t++) {
-        const i_a = indices[t * 3    ] * 3;
-        const i_b = indices[t * 3 + 1] * 3;
-        const i_c = indices[t * 3 + 2] * 3;
-
-        const ax = positions[i_a    ]; const ay = positions[i_a + 1]; const az = positions[i_a + 2];
-        const bx = positions[i_b    ]; const by = positions[i_b + 1]; const bz = positions[i_b + 2];
-        const cx = positions[i_c    ]; const cy = positions[i_c + 1]; const cz = positions[i_c + 2];
-
-        // tight per-triangle AABB
-        const tri_min_x = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx);
-        if (tri_min_x > aabb_max_x) continue;
-        const tri_max_x = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx);
-        if (tri_max_x < aabb_min_x) continue;
-
-        const tri_min_y = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy);
-        if (tri_min_y > aabb_max_y) continue;
-        const tri_max_y = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
-        if (tri_max_y < aabb_min_y) continue;
-
-        const tri_min_z = az < bz ? (az < cz ? az : cz) : (bz < cz ? bz : cz);
-        if (tri_min_z > aabb_max_z) continue;
-        const tri_max_z = az > bz ? (az > cz ? az : cz) : (bz > cz ? bz : cz);
-        if (tri_max_z < aabb_min_z) continue;
-
-        output[cursor    ] = ax; output[cursor + 1] = ay; output[cursor + 2] = az;
-        output[cursor + 3] = bx; output[cursor + 4] = by; output[cursor + 5] = bz;
-        output[cursor + 6] = cx; output[cursor + 7] = cy; output[cursor + 8] = cz;
-        output[cursor + TRIANGLE_FEATURE_ID_OFFSET] = t;
-
-        cursor += TRIANGLE_FLOAT_STRIDE;
-        count++;
-    }
-
-    return count;
-}
+import { TRIANGLE_FEATURE_ID_OFFSET, TRIANGLE_FLOAT_STRIDE } from "./triangle_buffer_layout.js";
+
+/**
+ * Write the mesh's surface triangles that may overlap the given query
+ * AABB into `output`, starting at float-index `offset`.
+ *
+ * Each triangle occupies {@link TRIANGLE_FLOAT_STRIDE} consecutive floats:
+ *   [+0..+2]  vA.xyz   (shape's body-local frame, i.e. read directly from
+ *                       {@link MeshShape3D#positions})
+ *   [+3..+5]  vB.xyz
+ *   [+6..+8]  vC.xyz
+ *   [+9]      feature_id   (the surface triangle's index + 1 — fid 0 is the
+ *                           narrowphase's "no feature info" sentinel, which
+ *                           would cost triangle 0's contacts their fid
+ *                           warm-start matching and per-substep redetect)
+ *
+ * Triangles are AABB-filtered: a triangle is emitted iff its tight AABB
+ * (min/max across its 3 vertices) overlaps the query AABB. This is a
+ * linear O(N) scan over the mesh's surface triangles — no surface-BVH
+ * yet (the existing BVH on MeshShape3D is over the *tet* decomposition
+ * used by `contains_point`, with different leaf semantics). For meshes
+ * up to a few thousand triangles the linear scan is comfortably faster
+ * than a BVH would be after broadphase has already given us a tight
+ * query AABB; we can graduate to a per-mesh surface BVH later.
+ *
+ * Determinism: triangles are emitted in the natural index order, so
+ * feature_id values inside `output` rise monotonically over a single
+ * call. The narrowphase relies on this for stable contact-manifold
+ * pairing across frames.
+ *
+ * Caller is responsible for ensuring
+ *   `output.length - offset >= shape.indices.length / 3 * TRIANGLE_FLOAT_STRIDE`
+ * in the worst case (every triangle overlaps).
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {MeshShape3D} shape
+ * @param {number} aabb_min_x  query AABB in shape's body-local frame
+ * @param {number} aabb_min_y
+ * @param {number} aabb_min_z
+ * @param {number} aabb_max_x
+ * @param {number} aabb_max_y
+ * @param {number} aabb_max_z
+ * @returns {number} number of triangles written
+ */
+export function mesh_enumerate_triangles(
+    output, offset, shape,
+    aabb_min_x, aabb_min_y, aabb_min_z,
+    aabb_max_x, aabb_max_y, aabb_max_z
+) {
+    const positions = shape.positions;
+    const indices = shape.indices;
+
+    const tri_count = (indices.length / 3) | 0;
+    if (tri_count === 0) {
+        return 0;
+    }
+
+    let count = 0;
+    let cursor = offset;
+
+    for (let t = 0; t < tri_count; t++) {
+        const i_a = indices[t * 3    ] * 3;
+        const i_b = indices[t * 3 + 1] * 3;
+        const i_c = indices[t * 3 + 2] * 3;
+
+        const ax = positions[i_a    ]; const ay = positions[i_a + 1]; const az = positions[i_a + 2];
+        const bx = positions[i_b    ]; const by = positions[i_b + 1]; const bz = positions[i_b + 2];
+        const cx = positions[i_c    ]; const cy = positions[i_c + 1]; const cz = positions[i_c + 2];
+
+        // tight per-triangle AABB
+        const tri_min_x = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx);
+        if (tri_min_x > aabb_max_x) continue;
+        const tri_max_x = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx);
+        if (tri_max_x < aabb_min_x) continue;
+
+        const tri_min_y = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy);
+        if (tri_min_y > aabb_max_y) continue;
+        const tri_max_y = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
+        if (tri_max_y < aabb_min_y) continue;
+
+        const tri_min_z = az < bz ? (az < cz ? az : cz) : (bz < cz ? bz : cz);
+        if (tri_min_z > aabb_max_z) continue;
+        const tri_max_z = az > bz ? (az > cz ? az : cz) : (bz > cz ? bz : cz);
+        if (tri_max_z < aabb_min_z) continue;
+
+        output[cursor    ] = ax; output[cursor + 1] = ay; output[cursor + 2] = az;
+        output[cursor + 3] = bx; output[cursor + 4] = by; output[cursor + 5] = bz;
+        output[cursor + 6] = cx; output[cursor + 7] = cy; output[cursor + 8] = cz;
+        output[cursor + TRIANGLE_FEATURE_ID_OFFSET] = t + 1; // 0 is the "no fid" sentinel
+
+        cursor += TRIANGLE_FLOAT_STRIDE;
+        count++;
+    }
+
+    return count;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"mesh_convex_hull.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/mesh_convex_hull.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,gDAJW;IAAC,QAAQ,CAAC;IAAC,aAAa,CAAC;IAAC,oBAAoB,CAAA;CAAC,GAC7C;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAC;IAAC,IAAI,EAAC,YAAY,CAAC;IAAC,OAAO,WAAS;CAAC,GAAC,IAAI,CAQ/H"}
+{"version":3,"file":"mesh_convex_hull.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/mesh_convex_hull.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,gDAJW;IAAC,QAAQ,CAAC;IAAC,aAAa,CAAC;IAAC,oBAAoB,CAAA;CAAC,GAC7C;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAC;IAAC,IAAI,EAAC,YAAY,CAAC;IAAC,OAAO,WAAS;CAAC,GAAC,IAAI,CAQ/H"}

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

@@ -1,5 +1,10 @@
+import { v3_compute_triangle_normal } from "../../../core/geom/3d/triangle/v3_compute_triangle_normal.js";
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
 import { build_piece, face_key, FACE_OPP } from "./convex_decomposition.js";
 
+// Reusable scratch for v3_compute_triangle_normal (writes a unit normal as 3 floats).
+const _face_normal = new Float64Array(3);
+
 /**
  * Convex fast path for a triangulated {@link MeshShape3D}: if the whole mesh is
  * convex, represent it as a single coplanar-merged convex piece so it collides
@@ -73,15 +78,15 @@ function build_if_convex(meshShape) {
         if (fc.count !== 1) continue;
         boundaryCount++;
         const ax = tp[fc.a * 3], ay = tp[fc.a * 3 + 1], az = tp[fc.a * 3 + 2];
-        const e1x = tp[fc.b * 3] - ax, e1y = tp[fc.b * 3 + 1] - ay, e1z = tp[fc.b * 3 + 2] - az;
-        const e2x = tp[fc.c * 3] - ax, e2y = tp[fc.c * 3 + 1] - ay, e2z = tp[fc.c * 3 + 2] - az;
-        let nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
+        v3_compute_triangle_normal(_face_normal, 0,
+            ax, ay, az,
+            tp[fc.b * 3], tp[fc.b * 3 + 1], tp[fc.b * 3 + 2],
+            tp[fc.c * 3], tp[fc.c * 3 + 1], tp[fc.c * 3 + 2]);
+        let ix = _face_normal[0], iy = _face_normal[1], iz = _face_normal[2];
         const ox = tp[fc.opp * 3] - ax, oy = tp[fc.opp * 3 + 1] - ay, oz = tp[fc.opp * 3 + 2] - az;
-        if (nx * ox + ny * oy + nz * oz > 0) { nx = -nx; ny = -ny; nz = -nz; } // outward
-        const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-        const ix = nx / len, iy = ny / len, iz = nz / len;
+        if (v3_dot(ix, iy, iz, ox, oy, oz) > 0) { ix = -ix; iy = -iy; iz = -iz; } // outward
         for (let v = 0; v < nVerts; v++) {
-            const d = ix * (tp[v * 3] - ax) + iy * (tp[v * 3 + 1] - ay) + iz * (tp[v * 3 + 2] - az);
+            const d = v3_dot(ix, iy, iz, tp[v * 3] - ax, tp[v * 3 + 1] - ay, tp[v * 3 + 2] - az);
             if (d > EPS) return null; // a vertex in front of a face → concave
         }
         boundary.set(k, { a: fc.a, b: fc.b, c: fc.c });
@@ -95,7 +100,7 @@ function build_if_convex(meshShape) {
     piece.support = function (result, result_offset, dx, dy, dz) {
         let bi = 0, best = -Infinity;
         for (let i = 0; i < vc; i++) {
-            const d = dx * v[i * 3] + dy * v[i * 3 + 1] + dz * v[i * 3 + 2];
+            const d = v3_dot(dx, dy, dz, v[i * 3], v[i * 3 + 1], v[i * 3 + 2]);
             if (d > best) { best = d; bi = i; }
         }
         result[result_offset] = v[bi * 3];

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

@@ -1,117 +1,117 @@
-import { bvh_query_user_data_overlaps_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
-import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
-import { aabb_world_to_local } from "./decomposition/aabb_world_to_local.js";
-import { build_convex_decomposition } from "./convex_decomposition.js";
-import { convex_convex_manifold, CONVEX_CONVEX_OUT_LENGTH } from "./convex_convex_manifold.js";
-
-/**
- * Contact generation between two triangulated meshes, each treated as the union
- * of its CONVEX PIECES (from greedy tet-merge — see {@link build_convex_decomposition}).
- * Concave-vs-concave reduced to convex piece-vs-piece, the standard
- * convex-decomposition approach.
- *
- * Only piece pairs whose AABBs overlap reach the SAT + face-clip manifold:
- * project mesh B's world AABB into A's local frame and query A's piece BVH; for
- * each candidate piece of A, project its world AABB into B's local frame and
- * query B's piece BVH. One top-level broadphase leaf per body; the per-shape
- * piece BVHs do the culling. Merging keeps the piece count (and the per-pair
- * SAT cost) far below the raw tet count — the path to large tet counts.
- *
- * The decomposition is built once per shape and cached (shapes are immutable,
- * shared, and the decomposition is in the shape's local frame). Per-frame, no
- * cross-frame state → reset-and-resimulate determinism preserved.
- *
- * @author Alex Goldring
- * @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);
-const local_bbox = new Float64Array(6);
-const world_aabb = new Float64Array(6);
-const query_aabb = new Float64Array(6);
-
-/** Build + cache the convex decomposition on the (immutable, shared) shape. */
-function get_decomposition(shape) {
-    let d = shape.__convex_decomposition;
-    if (d === undefined) {
-        d = build_convex_decomposition(shape);
-        shape.__convex_decomposition = d;
-    }
-    return d;
-}
-
-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`.
- *
- * @returns {number} new candidate count
- */
-export function mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append) {
-    const decompA = get_decomposition(shapeA);
-    const decompB = get_decomposition(shapeB);
-    const piecesA = decompA.pieces;
-    const piecesB = decompB.pieces;
-
-    // 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.position.x, trB.position.y, trB.position.z,
-        trB.rotation.x, trB.rotation.y, trB.rotation.z, trB.rotation.w
-    );
-    aabb_world_to_local(
-        query_aabb, 0, world_aabb,
-        trA.position.x, trA.position.y, trA.position.z,
-        trA.rotation.x, trA.rotation.y, trA.rotation.z, trA.rotation.w
-    );
-
-    cand_a = ensure(cand_a, piecesA.length);
-    const nA = bvh_query_user_data_overlaps_aabb(cand_a, 0, decompA.bvh, query_aabb);
-
-    for (let i = 0; i < nA; i++) {
-        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.position.x, trA.position.y, trA.position.z,
-            trA.rotation.x, trA.rotation.y, trA.rotation.z, trA.rotation.w
-        );
-        aabb_world_to_local(
-            query_aabb, 0, world_aabb,
-            trB.position.x, trB.position.y, trB.position.z,
-            trB.rotation.x, trB.rotation.y, trB.rotation.z, trB.rotation.w
-        );
-        cand_b = ensure(cand_b, piecesB.length);
-        const nB = bvh_query_user_data_overlaps_aabb(cand_b, 0, decompB.bvh, query_aabb);
-
-        for (let j = 0; j < nB; j++) {
-            const pieceB = piecesB[cand_b[j]];
-            if (!convex_convex_manifold(piece_out, pieceA, trA.position, trA.rotation, pieceB, trB.position, trB.rotation)) {
-                continue;
-            }
-            const cc = piece_out[3] | 0;
-            const nx = piece_out[0], ny = piece_out[1], nz = piece_out[2];
-            for (let k = 0; k < cc; k++) {
-                const base = 4 + k * 7;
-                count = append(count,
-                    piece_out[base], piece_out[base + 1], piece_out[base + 2],
-                    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;
-}
+import { bvh_query_user_data_overlaps_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_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 { build_convex_decomposition } from "./convex_decomposition.js";
+import { convex_convex_manifold, CONVEX_CONVEX_OUT_LENGTH } from "./convex_convex_manifold.js";
+
+/**
+ * Contact generation between two triangulated meshes, each treated as the union
+ * of its CONVEX PIECES (from greedy tet-merge — see {@link build_convex_decomposition}).
+ * Concave-vs-concave reduced to convex piece-vs-piece, the standard
+ * convex-decomposition approach.
+ *
+ * Only piece pairs whose AABBs overlap reach the SAT + face-clip manifold:
+ * project mesh B's world AABB into A's local frame and query A's piece BVH; for
+ * each candidate piece of A, project its world AABB into B's local frame and
+ * query B's piece BVH. One top-level broadphase leaf per body; the per-shape
+ * piece BVHs do the culling. Merging keeps the piece count (and the per-pair
+ * SAT cost) far below the raw tet count — the path to large tet counts.
+ *
+ * The decomposition is built once per shape and cached (shapes are immutable,
+ * shared, and the decomposition is in the shape's local frame). Per-frame, no
+ * cross-frame state → reset-and-resimulate determinism preserved.
+ *
+ * @author Alex Goldring
+ * @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);
+const local_bbox = new Float64Array(6);
+const world_aabb = new Float64Array(6);
+const query_aabb = new Float64Array(6);
+
+/** Build + cache the convex decomposition on the (immutable, shared) shape. */
+function get_decomposition(shape) {
+    let d = shape.__convex_decomposition;
+    if (d === undefined) {
+        d = build_convex_decomposition(shape);
+        shape.__convex_decomposition = d;
+    }
+    return d;
+}
+
+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`.
+ *
+ * @returns {number} new candidate count
+ */
+export function mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append) {
+    const decompA = get_decomposition(shapeA);
+    const decompB = get_decomposition(shapeB);
+    const piecesA = decompA.pieces;
+    const piecesB = decompB.pieces;
+
+    // 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.position.x, trB.position.y, trB.position.z,
+        trB.rotation.x, trB.rotation.y, trB.rotation.z, trB.rotation.w
+    );
+    aabb3_transform_oriented_inverse(
+        query_aabb, 0, world_aabb,
+        trA.position.x, trA.position.y, trA.position.z,
+        trA.rotation.x, trA.rotation.y, trA.rotation.z, trA.rotation.w
+    );
+
+    cand_a = ensure(cand_a, piecesA.length);
+    const nA = bvh_query_user_data_overlaps_aabb(cand_a, 0, decompA.bvh, query_aabb);
+
+    for (let i = 0; i < nA; i++) {
+        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.position.x, trA.position.y, trA.position.z,
+            trA.rotation.x, trA.rotation.y, trA.rotation.z, trA.rotation.w
+        );
+        aabb3_transform_oriented_inverse(
+            query_aabb, 0, world_aabb,
+            trB.position.x, trB.position.y, trB.position.z,
+            trB.rotation.x, trB.rotation.y, trB.rotation.z, trB.rotation.w
+        );
+        cand_b = ensure(cand_b, piecesB.length);
+        const nB = bvh_query_user_data_overlaps_aabb(cand_b, 0, decompB.bvh, query_aabb);
+
+        for (let j = 0; j < nB; j++) {
+            const pieceB = piecesB[cand_b[j]];
+            if (!convex_convex_manifold(piece_out, pieceA, trA.position, trA.rotation, pieceB, trB.position, trB.rotation)) {
+                continue;
+            }
+            const cc = piece_out[3] | 0;
+            const nx = piece_out[0], ny = piece_out[1], nz = piece_out[2];
+            for (let k = 0; k < cc; k++) {
+                const base = 4 + k * 7;
+                count = append(count,
+                    piece_out[base], piece_out[base + 1], piece_out[base + 2],
+                    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.map

@@ -1 +1 @@
-{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAk1CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qDAVW,YAAY,GAAC,MAAM,EAAE,iCAGrB;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iCAErC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,GACnC,MAAM,CAuClB;AAED;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,CAAC,QAiKlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,UACjD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,QA8G3D"}
+{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAyyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qDAVW,YAAY,GAAC,MAAM,EAAE,iCAGrB;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iCAErC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,GACnC,MAAM,CAuClB;AAED;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,CAAC,QA4LlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,UACjD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,QA2H3D"}