@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -65,13 +65,13 @@ export function mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append)
     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
+        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.position.x, trA.position.y, trA.position.z,
-        trA.rotation.x, trA.rotation.y, trA.rotation.z, trA.rotation.w
+        trA.translation_x, trA.translation_y, trA.translation_z,
+        trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w
     );
 
     cand_a = ensure(cand_a, piecesA.length);
@@ -85,20 +85,20 @@ export function mesh_mesh_tet_contacts(count, shapeA, trA, shapeB, trB, append)
         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
+            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.position.x, trB.position.y, trB.position.z,
-            trB.rotation.x, trB.rotation.y, trB.rotation.z, trB.rotation.w
+            trB.translation_x, trB.translation_y, trB.translation_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_intersects_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)) {
+            if (!convex_convex_manifold(piece_out, pieceA, trA.translation, trA.rotation, pieceB, trB.translation, trB.rotation)) {
                 continue;
             }
             const cc = piece_out[3] | 0;

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":"AA2zCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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,CA2ClB;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"}

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

@@ -32,6 +32,7 @@ import { PosedShape3D } from "../../../core/geom/3d/shape/PosedShape3D.js";
 import { sphere_box_contact } from "./sphere_box_contact.js";
 import { sphere_sphere_contact } from "./sphere_sphere_contact.js";
 import { sphere_triangle_contact } from "./sphere_triangle_contact.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 
 const posed_a = new PosedShape3D();
 const posed_b = new PosedShape3D();
@@ -384,16 +385,24 @@ function sphere_box_voronoi_fid(sx, sy, sz, bx, by, bz, bqx, bqy, bqz, bqw, hx,
  * @returns {number}
  */
 function hull_pair_contacts(count, hullA, trA, hullB, trB, append_contact) {
-    posed_a.setup(hullA, trA.position, trA.rotation);
-    posed_b.setup(hullB, trB.position, trB.rotation);
+    posed_a.setup_components(
+        hullA,
+        trA.translation_x, trA.translation_y, trA.translation_z,
+        trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w
+    );
+    posed_b.setup_components(
+        hullB,
+        trB.translation_x, trB.translation_y, trB.translation_z,
+        trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w
+    );
     const depth = gjk_epa_penetration(epa_result, posed_a, posed_b);
     if (!(depth > 0) || !Number.isFinite(depth)) return count;
 
     // convex_hull_clip orients the axis B→A robustly (via vertex centroids) and
     // writes the final normal into convex_manifold_result[0..2].
     convex_hull_clip(convex_manifold_result,
-        hullA, trA.position, trA.rotation,
-        hullB, trB.position, trB.rotation,
+        hullA, trA.translation, trA.rotation,
+        hullB, trB.translation, trB.rotation,
         epa_result[0], epa_result[1], epa_result[2]);
     const nx = convex_manifold_result[0], ny = convex_manifold_result[1], nz = convex_manifold_result[2];
     const cc = convex_manifold_result[3] | 0;
@@ -461,8 +470,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
         const ok = sphere_sphere_contact(
             sphere_result,
-            trA.position.x, trA.position.y, trA.position.z,
-            trB.position.x, trB.position.y, trB.position.z,
+            trA.translation_x, trA.translation_y, trA.translation_z,
+            trB.translation_x, trB.translation_y, trB.translation_z,
             ra, rb
         );
 
@@ -475,8 +484,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         // and is trivially stable across frames. Witnesses are the surface
         // points along the (unit) normal, scaled by each sphere's radius.
         return append_contact(count,
-            trA.position.x - nx * ra, trA.position.y - ny * ra, trA.position.z - nz * ra,
-            trB.position.x + nx * rb, trB.position.y + ny * rb, trB.position.z + nz * rb,
+            trA.translation_x - nx * ra, trA.translation_y - ny * ra, trA.translation_z - nz * ra,
+            trB.translation_x + nx * rb, trB.translation_y + ny * rb, trB.translation_z + nz * rb,
             nx, ny, nz, sphere_result[3], 1);
     }
 
@@ -490,9 +499,9 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
         const ok = sphere_box_contact(
             closed_form_result,
-            sphereTr.position.x, sphereTr.position.y, sphereTr.position.z, sphereShape.radius,
-            boxTr.position.x, boxTr.position.y, boxTr.position.z,
-            boxTr.rotation.x, boxTr.rotation.y, boxTr.rotation.z, boxTr.rotation.w,
+            sphereTr.translation_x, sphereTr.translation_y, sphereTr.translation_z, sphereShape.radius,
+            boxTr.translation_x, boxTr.translation_y, boxTr.translation_z,
+            boxTr.rotation_x, boxTr.rotation_y, boxTr.rotation_z, boxTr.rotation_w,
             bh.x, bh.y, bh.z
         );
 
@@ -508,9 +517,9 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         // box, which is the steady-state case for resting / sliding contact.
 
         const fid = sphere_box_voronoi_fid(
-            sphereTr.position.x, sphereTr.position.y, sphereTr.position.z,
-            boxTr.position.x, boxTr.position.y, boxTr.position.z,
-            boxTr.rotation.x, boxTr.rotation.y, boxTr.rotation.z, boxTr.rotation.w,
+            sphereTr.translation_x, sphereTr.translation_y, sphereTr.translation_z,
+            boxTr.translation_x, boxTr.translation_y, boxTr.translation_z,
+            boxTr.rotation_x, boxTr.rotation_y, boxTr.rotation_z, boxTr.rotation_w,
             bh.x, bh.y, bh.z
         );
 
@@ -527,11 +536,11 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const bh = shapeB.half_extents;
         const ok = box_box_manifold(
             box_manifold_result,
-            trA.position.x, trA.position.y, trA.position.z,
-            trA.rotation.x, trA.rotation.y, trA.rotation.z, trA.rotation.w,
+            trA.translation_x, trA.translation_y, trA.translation_z,
+            trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w,
             ah.x, ah.y, ah.z,
-            trB.position.x, trB.position.y, trB.position.z,
-            trB.rotation.x, trB.rotation.y, trB.rotation.z, trB.rotation.w,
+            trB.translation_x, trB.translation_y, trB.translation_z,
+            trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w,
             bh.x, bh.y, bh.z
         );
         if (!ok) return count;
@@ -562,11 +571,11 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const a_shape = colA.shape, b_shape = colB.shape;
         const n_cc = capsule_capsule_multi_contacts(
             capsule_capsule_result,
-            trA.position.x, trA.position.y, trA.position.z,
-            trA.rotation.x, trA.rotation.y, trA.rotation.z, trA.rotation.w,
+            trA.translation_x, trA.translation_y, trA.translation_z,
+            trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w,
             a_shape.radius, a_shape.height * 0.5,
-            trB.position.x, trB.position.y, trB.position.z,
-            trB.rotation.x, trB.rotation.y, trB.rotation.z, trB.rotation.w,
+            trB.translation_x, trB.translation_y, trB.translation_z,
+            trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w,
             b_shape.radius, b_shape.height * 0.5
         );
         for (let k = 0; k < n_cc; k++) {
@@ -589,10 +598,10 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const sphereShape = isCapsuleA ? colB.shape : colA.shape;
         const ok = capsule_sphere_contact(
             closed_form_result,
-            capsuleTr.position.x, capsuleTr.position.y, capsuleTr.position.z,
-            capsuleTr.rotation.x, capsuleTr.rotation.y, capsuleTr.rotation.z, capsuleTr.rotation.w,
+            capsuleTr.translation_x, capsuleTr.translation_y, capsuleTr.translation_z,
+            capsuleTr.rotation_x, capsuleTr.rotation_y, capsuleTr.rotation_z, capsuleTr.rotation_w,
             capsuleShape.radius, capsuleShape.height * 0.5,
-            sphereTr.position.x, sphereTr.position.y, sphereTr.position.z, sphereShape.radius
+            sphereTr.translation_x, sphereTr.translation_y, sphereTr.translation_z, sphereShape.radius
         );
         if (!ok) return count;
         let nx = closed_form_result[0], ny = closed_form_result[1], nz = closed_form_result[2];
@@ -616,11 +625,11 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         const bh = boxShape.half_extents;
         const cc = capsule_box_multi_contacts(
             capsule_box_multi_result,
-            capsuleTr.position.x, capsuleTr.position.y, capsuleTr.position.z,
-            capsuleTr.rotation.x, capsuleTr.rotation.y, capsuleTr.rotation.z, capsuleTr.rotation.w,
+            capsuleTr.translation_x, capsuleTr.translation_y, capsuleTr.translation_z,
+            capsuleTr.rotation_x, capsuleTr.rotation_y, capsuleTr.rotation_z, capsuleTr.rotation_w,
             capsuleShape.radius, capsuleShape.height * 0.5,
-            boxTr.position.x, boxTr.position.y, boxTr.position.z,
-            boxTr.rotation.x, boxTr.rotation.y, boxTr.rotation.z, boxTr.rotation.w,
+            boxTr.translation_x, boxTr.translation_y, boxTr.translation_z,
+            boxTr.rotation_x, boxTr.rotation_y, boxTr.rotation_z, boxTr.rotation_w,
             bh.x, bh.y, bh.z
         );
         if (cc === 0) return count;
@@ -697,16 +706,16 @@ function dispatch_pair(count, colA, trA, colB, trB) {
             concave_world_aabb, 0,
             concave_local_aabb[0], concave_local_aabb[1], concave_local_aabb[2],
             concave_local_aabb[3], concave_local_aabb[4], concave_local_aabb[5],
-            convex_tr.position.x, convex_tr.position.y, convex_tr.position.z,
-            convex_tr.rotation.x, convex_tr.rotation.y, convex_tr.rotation.z, convex_tr.rotation.w
+            convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
+            convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w
         );
 
         // 2. Project into concave's body-local frame.
         aabb3_transform_oriented_inverse(
             concave_query_aabb, 0,
             concave_world_aabb,
-            concave_tr.position.x, concave_tr.position.y, concave_tr.position.z,
-            concave_tr.rotation.x, concave_tr.rotation.y, concave_tr.rotation.z, concave_tr.rotation.w
+            concave_tr.translation_x, concave_tr.translation_y, concave_tr.translation_z,
+            concave_tr.rotation_x, concave_tr.rotation_y, concave_tr.rotation_z, concave_tr.rotation_w
         );
 
         // 3. Decompose concave shape into triangles overlapping the query.
@@ -726,21 +735,25 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         //    the concave side as our internal "A" so EPA's sign-check
         //    convention matches the convex fallback below; the final
         //    append_contact() swaps if the original A was the convex one.
-        posed_b.setup(convex_col.shape, convex_tr.position, convex_tr.rotation);
+        posed_b.setup_components(
+        convex_col.shape,
+        convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
+        convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w
+    );
         posed_a.shape = triangle_shape;
-        posed_a.px = concave_tr.position.x;
-        posed_a.py = concave_tr.position.y;
-        posed_a.pz = concave_tr.position.z;
-        posed_a.qx = concave_tr.rotation.x;
-        posed_a.qy = concave_tr.rotation.y;
-        posed_a.qz = concave_tr.rotation.z;
-        posed_a.qw = concave_tr.rotation.w;
+        posed_a.px = concave_tr.translation_x;
+        posed_a.py = concave_tr.translation_y;
+        posed_a.pz = concave_tr.translation_z;
+        posed_a.qx = concave_tr.rotation_x;
+        posed_a.qy = concave_tr.rotation_y;
+        posed_a.qz = concave_tr.rotation_z;
+        posed_a.qw = concave_tr.rotation_w;
 
         // Pre-compute the centre-axis used by EPA's sign-check loop.
         // For convex-vs-convex this is `(B - A) = convex_centre − concave_centre`.
-        const convex_wx = convex_tr.position.x;
-        const convex_wy = convex_tr.position.y;
-        const convex_wz = convex_tr.position.z;
+        const convex_wx = convex_tr.translation_x;
+        const convex_wy = convex_tr.translation_y;
+        const convex_wz = convex_tr.translation_z;
 
         // Track the candidate-buffer index at the start of this
         // concave dispatch — the per-triangle dedup pass scans from
@@ -750,13 +763,13 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
         // Pre-compute concave's rotation components for the q · v · q⁻¹
         // rotations done per-triangle below (face normal + centroid).
-        const cqx = concave_tr.rotation.x;
-        const cqy = concave_tr.rotation.y;
-        const cqz = concave_tr.rotation.z;
-        const cqw = concave_tr.rotation.w;
-        const c_pos_x = concave_tr.position.x;
-        const c_pos_y = concave_tr.position.y;
-        const c_pos_z = concave_tr.position.z;
+        const cqx = concave_tr.rotation_x;
+        const cqy = concave_tr.rotation_y;
+        const cqz = concave_tr.rotation_z;
+        const cqw = concave_tr.rotation_w;
+        const c_pos_x = concave_tr.translation_x;
+        const c_pos_y = concave_tr.translation_y;
+        const c_pos_z = concave_tr.translation_z;
 
         // Sphere fast-path: when the convex side is a sphere we bypass GJK+EPA
         // entirely per triangle and use the closed-form
@@ -935,8 +948,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
                 const ok = box_triangle_contact(
                     box_triangle_result,
-                    convex_tr.position.x, convex_tr.position.y, convex_tr.position.z,
-                    convex_tr.rotation.x, convex_tr.rotation.y, convex_tr.rotation.z, convex_tr.rotation.w,
+                    convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
+                    convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w,
                     box_half_extents.x, box_half_extents.y, box_half_extents.z,
                     ax_w, ay_w, az_w,
                     bx_w, by_w, bz_w,
@@ -1040,8 +1053,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 
                 const cap_cc = capsule_triangle_contact(
                     capsule_triangle_result,
-                    convex_tr.position.x, convex_tr.position.y, convex_tr.position.z,
-                    convex_tr.rotation.x, convex_tr.rotation.y, convex_tr.rotation.z, convex_tr.rotation.w,
+                    convex_tr.translation_x, convex_tr.translation_y, convex_tr.translation_z,
+                    convex_tr.rotation_x, convex_tr.rotation_y, convex_tr.rotation_z, convex_tr.rotation_w,
                     capsule_shape.radius, capsule_shape.height * 0.5,
                     ax_w, ay_w, az_w,
                     bx_w, by_w, bz_w,
@@ -1242,8 +1255,16 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     // expanding_polytope_algorithm pair, which returned a non-minimal axis on the
     // degenerate simplices its GJK produced (see memory:
     // feedback_epa_unreliable_polytopes). MPR is kept as a secondary safety net.
-    posed_a.setup(colA.shape, trA.position, trA.rotation);
-    posed_b.setup(colB.shape, trB.position, trB.rotation);
+    posed_a.setup_components(
+        colA.shape,
+        trA.translation_x, trA.translation_y, trA.translation_z,
+        trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w
+    );
+    posed_b.setup_components(
+        colB.shape,
+        trB.translation_x, trB.translation_y, trB.translation_z,
+        trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w
+    );
 
     let ex, ey, ez, depth;
     const pen_depth = gjk_epa_penetration(epa_result, posed_a, posed_b);
@@ -1290,9 +1311,9 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     // separation direction. For pathological cases (deeply
     // interpenetrating bodies with coincident centres) the dot product
     // is near zero and we leave EPA's guess intact.
-    const ab_x = trB.position.x - trA.position.x;
-    const ab_y = trB.position.y - trA.position.y;
-    const ab_z = trB.position.z - trA.position.z;
+    const ab_x = trB.translation_x - trA.translation_x;
+    const ab_y = trB.translation_y - trA.translation_y;
+    const ab_z = trB.translation_z - trA.translation_z;
     if (ex * ab_x + ey * ab_y + ez * ab_z < 0) {
         ex = -ex; ey = -ey; ez = -ez;
     }
@@ -1320,8 +1341,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     // GJK+EPA fallback has no stable per-frame feature info; emit fid = 0
     // so match-and-merge uses position-fallback. Single contact per pair.
     return append_contact(count,
-        trA.position.x, trA.position.y, trA.position.z,
-        trB.position.x, trB.position.y, trB.position.z,
+        trA.translation_x, trA.translation_y, trA.translation_z,
+        trB.translation_x, trB.translation_y, trB.translation_z,
         nx, ny, nz,
         depth, 0
     );
@@ -1333,8 +1354,10 @@ function dispatch_pair(count, colA, trA, colB, trB) {
 // all it needs.
 const _pp_colA = { shape: null };
 const _pp_colB = { shape: null };
-const _pp_trA = { position: null, rotation: null };
-const _pp_trB = { position: null, rotation: null };
+// Stand-in transforms for the pose-only entry points. They carry the same scalar accessors the
+// dispatch reads off a real component, so the two paths stay one code path.
+const _pp_trA = new Transform64();
+const _pp_trB = new Transform64();
 
 
 /**
@@ -1372,11 +1395,15 @@ const _pp_trB = { position: null, rotation: null };
  */
 export function deepest_pair_penetration(out_normal, shapeA, posA, rotA, shapeB, posB, rotB) {
     _pp_colA.shape = shapeA;
-    _pp_trA.position = posA;
-    _pp_trA.rotation = rotA;
+    _pp_trA.setTranslation(posA[0], posA[1], posA[2]);
+    _pp_trA.setRotation(rotA[0], rotA[1], rotA[2], rotA[3]);
     _pp_colB.shape = shapeB;
-    _pp_trB.position = posB;
-    _pp_trB.rotation = rotB;
+    _pp_trB.setTranslation(posB[0], posB[1], posB[2]);
+    _pp_trB.setRotation(rotB[0], rotB[1], rotB[2], rotB[3]);
+
+    // the rotations moved, so the matrices are behind the components
+    _pp_trA.updateMatrix();
+    _pp_trB.updateMatrix();
 
     const n = dispatch_pair(0, _pp_colA, _pp_trA, _pp_colB, _pp_trB);
     if (n === 0) {

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

@@ -55,7 +55,7 @@ const AABB_FATTEN = 1e-5; // guards triangles whose AABB just abuts the segment
 export function refine_ray_concave(shape, position, rotation, ox, oy, oz, dx, dy, dz, tMax, outNormal) {
     const qx = rotation[0], qy = rotation[1], qz = rotation[2], qw = rotation[3];
     // World → local (inverse body rotation; unit dir stays unit → t preserved).
-    v3_quaternion_apply_inverse(lo, 0, ox - position.x, oy - position.y, oz - position.z, qx, qy, qz, qw);
+    v3_quaternion_apply_inverse(lo, 0, ox - position[0], oy - position[1], oz - position[2], qx, qy, qz, qw);
     v3_quaternion_apply_inverse(ld, 0, dx, dy, dz, qx, qy, qz, qw);
     const lox = lo[0], loy = lo[1], loz = lo[2];
     const ldx = ld[0], ldy = ld[1], ldz = ld[2];

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

@@ -23,7 +23,7 @@ const ld = new Float64Array(3); // ray direction in shape-local frame
 const ln = new Float64Array(3); // surface normal in shape-local frame
 
 /** Identity pose for delegating a ray that is ALREADY in the shape's frame. */
-const LOCAL_ORIGIN = { x: 0, y: 0, z: 0 };
+const LOCAL_ORIGIN = [0, 0, 0];
 const LOCAL_IDENTITY = [0, 0, 0, 1];
 
 /**
@@ -253,7 +253,7 @@ export function refine_ray_hit(shape, position, rotation, ox, oy, oz, dx, dy, dz
     if (shape.isSphereShape3D === true) {
         // Rotation-invariant: translate into the sphere's frame; the local
         // normal is already the world normal.
-        return sphere_raycast(outNormal, 0, ox - position.x, oy - position.y, oz - position.z, dx, dy, dz, tMax, shape.radius);
+        return sphere_raycast(outNormal, 0, ox - position[0], oy - position[1], oz - position[2], dx, dy, dz, tMax, shape.radius);
     }
 
     if (shape.isMeshShape3D === true || shape.isHeightMapShape3D === true) {
@@ -264,7 +264,7 @@ export function refine_ray_hit(shape, position, rotation, ox, oy, oz, dx, dy, dz
 
     const qx = rotation[0], qy = rotation[1], qz = rotation[2], qw = rotation[3];
     // World → local: rotate by the inverse (conjugate) body rotation.
-    v3_quaternion_apply_inverse(lo, 0, ox - position.x, oy - position.y, oz - position.z, qx, qy, qz, qw);
+    v3_quaternion_apply_inverse(lo, 0, ox - position[0], oy - position[1], oz - position[2], qx, qy, qz, qw);
     v3_quaternion_apply_inverse(ld, 0, dx, dy, dz, qx, qy, qz, qw);
 
     const t = refine_ray_local(shape, lo[0], lo[1], lo[2], ld[0], ld[1], ld[2], tMax, ln);

package/src/engine/physics/queries/overlap_shape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlap_shape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/overlap_shape.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAZW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAE5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,UAErC,WAAW,GAAC,MAAM,EAAE,iBAEpB,MAAM,oBACE,MAAM,yBAAsB,OAAO,GAEzC,MAAM,CAuGlB"}
+{"version":3,"file":"overlap_shape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/overlap_shape.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAZW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAE5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,UAErC,WAAW,GAAC,MAAM,EAAE,iBAEpB,MAAM,oBACE,MAAM,yBAAsB,OAAO,GAEzC,MAAM,CAmHlB"}

package/src/engine/physics/queries/overlap_shape.js

@@ -95,8 +95,8 @@ export function overlap_shape(system, shape, position, rotation, output, output_
         world_aabb, 0,
         local_aabb[0], local_aabb[1], local_aabb[2],
         local_aabb[3], local_aabb[4], local_aabb[5],
-        position.x, position.y, position.z,
-        rotation.x, rotation.y, rotation.z, rotation.w
+        position[0], position[1], position[2],
+        rotation[0], rotation[1], rotation[2], rotation[3]
     );
 
     // ── 2. Gather broadphase candidates ─────────────────────────────
@@ -116,7 +116,11 @@ export function overlap_shape(system, shape, position, rotation, output, output_
     if (n_total === 0) return 0;
 
     // ── 3. Set up query PosedShape3D (constant across candidates) ─────
-    query_posed.setup(shape, position, rotation);
+    query_posed.setup_components(
+        shape,
+        position[0], position[1], position[2],
+        rotation[0], rotation[1], rotation[2], rotation[3]
+    );
 
     // ── 4. Per-candidate narrowphase ────────────────────────────────
     const output_capacity = output.length - output_offset;
@@ -141,7 +145,11 @@ export function overlap_shape(system, shape, position, rotation, output, output_
         let overlaps = false;
 
         if (collider.shape.is_convex !== false) {
-            candidate_posed.setup(collider.shape, candidate_tr.position, candidate_tr.rotation);
+            candidate_posed.setup_components(
+                collider.shape,
+                candidate_tr.translation_x, candidate_tr.translation_y, candidate_tr.translation_z,
+                candidate_tr.rotation_x, candidate_tr.rotation_y, candidate_tr.rotation_z, candidate_tr.rotation_w
+            );
             overlaps = gjk(simplex_buf, query_posed, candidate_posed);
         } else {
             // Concave candidate: project the query's world AABB into
@@ -150,8 +158,8 @@ export function overlap_shape(system, shape, position, rotation, output, output_
             aabb3_transform_oriented_inverse(
                 concave_query_aabb, 0,
                 world_aabb,
-                candidate_tr.position.x, candidate_tr.position.y, candidate_tr.position.z,
-                candidate_tr.rotation.x, candidate_tr.rotation.y, candidate_tr.rotation.z, candidate_tr.rotation.w
+                candidate_tr.translation_x, candidate_tr.translation_y, candidate_tr.translation_z,
+                candidate_tr.rotation_x, candidate_tr.rotation_y, candidate_tr.rotation_z, candidate_tr.rotation_w
             );
 
             let tri_count = decompose_to_triangles(
@@ -165,7 +173,11 @@ export function overlap_shape(system, shape, position, rotation, output, output_
 
             // Re-pose candidate as the concave body (the flyweight triangle is
             // rebound per iteration below; setup only stores the shape reference).
-            candidate_posed.setup(triangle_shape, candidate_tr.position, candidate_tr.rotation);
+            candidate_posed.setup_components(
+                triangle_shape,
+                candidate_tr.translation_x, candidate_tr.translation_y, candidate_tr.translation_z,
+                candidate_tr.rotation_x, candidate_tr.rotation_y, candidate_tr.rotation_z, candidate_tr.rotation_w
+            );
 
             for (let t = 0; t < tri_count; t++) {
                 triangle_shape.bind(triangle_buffer, t * TRIANGLE_FLOAT_STRIDE);

package/src/engine/physics/queries/raycast.js

@@ -130,7 +130,7 @@ function bvh_raycast_nearest(
 
         const tr = system.__transforms[idx];
         const refined = refine_ray_hit(
-            collider.shape, tr.position, tr.rotation,
+            collider.shape, tr.translation, tr.rotation,
             ox, oy, oz, dx, dy, dz, acc.best_t, cand_normal
         );
 
@@ -146,8 +146,8 @@ function bvh_raycast_nearest(
                 scratch_tight_world, 0,
                 scratch_tight_local[0], scratch_tight_local[1], scratch_tight_local[2],
                 scratch_tight_local[3], scratch_tight_local[4], scratch_tight_local[5],
-                tr.position.x, tr.position.y, tr.position.z,
-                tr.rotation.x, tr.rotation.y, tr.rotation.z, tr.rotation.w
+                tr.translation_x, tr.translation_y, tr.translation_z,
+                tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w
             );
             const tight_t = aabb3_ray_segment_entry_distance(
                 scratch_tight_world[0], scratch_tight_world[1], scratch_tight_world[2],

package/src/engine/physics/queries/shape_cast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shape_cast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/shape_cast.js"],"names":[],"mappings":"AAoPA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,8FAnBW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iDAE7B,MAAM,+BAA6B,MAAM,KAAG,OAAO,0BAI3D,OAAO,GAWL,OAAO,CAsTnB"}
+{"version":3,"file":"shape_cast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/shape_cast.js"],"names":[],"mappings":"AAoPA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,8FAnBW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iDAE7B,MAAM,+BAA6B,MAAM,KAAG,OAAO,0BAI3D,OAAO,GAWL,OAAO,CA8TnB"}