@woosh/meep-engine 2.155.0 → 2.157.0

package/src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAiFlB"}
+{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAkFlB"}

package/src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js

@@ -82,8 +82,9 @@ export function line3_compute_segment_point_distance_eikonal(
     const coef = p / det_sqrt;
     const s = x_local - y * coef; // Intersection with x-axis
 
-    if (s > 0) {
-        // 5. Valid Eikonal Update
+    if (s > 0 && s < L) {
+        // 5. Valid Eikonal Update — the characteristic foot must land strictly inside the segment (0, L);
+        // an s >= L means the geodesic actually wraps via the far vertex, handled by the fallback below.
         return u0 + (p * x_local + y * det_sqrt) / q;
     } else {
         // 6. Fallback (The path comes strictly from one of the vertices)

package/src/core/geom/3d/mat4/decompose_matrix_4_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decompose_matrix_4_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/decompose_matrix_4_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,+CALW,MAAM,EAAE,yDA6DlB"}
+{"version":3,"file":"decompose_matrix_4_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/decompose_matrix_4_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,+CALW,MAAM,EAAE,yDAuElB"}

package/src/core/geom/3d/mat4/decompose_matrix_4_array.js

@@ -26,9 +26,19 @@ export function decompose_matrix_4_array(mat4, position, rotation, scale) {
 
     const scale_z = v3_length(m31, m32, m33);
 
+    // If the upper-left 3x3 has a negative determinant the matrix encodes a reflection; fold that sign into
+    // one scale axis (matching three.js, which negates scale.x) so the extracted rotation is a proper rotation
+    // rather than a mirror (which __setFromRotationMatrix would decode incorrectly).
+    const det =
+        m11 * (m22 * m33 - m23 * m32)
+        - m12 * (m21 * m33 - m23 * m31)
+        + m13 * (m21 * m32 - m22 * m31);
+
+    const signed_scale_x = det < 0 ? -scale_x : scale_x;
+
     // extract rotation matrix
     // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
-    const is1 = scale_x !== 0 ? 1 / scale_x : 1e7;
+    const is1 = signed_scale_x !== 0 ? 1 / signed_scale_x : 1e7;
     const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
     const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
 
@@ -53,7 +63,7 @@ export function decompose_matrix_4_array(mat4, position, rotation, scale) {
     );
 
     scale.set(
-        scale_x,
+        signed_scale_x,
         scale_y,
         scale_z
     );

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.js

@@ -62,7 +62,7 @@ export function eulerAnglesFromMatrix(
     if (a0 === a2) {
         output[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
 
-        if ((odd && output[0] < 0) || ((~odd) && output[0] > 0)) {
+        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
             if (output[0] > 0) {
                 output[0] -= Math.PI;
             } else {
@@ -96,7 +96,7 @@ export function eulerAnglesFromMatrix(
 
         const c2 = v2_length(coeff(m4, i, i), coeff(m4, i, j));
 
-        if ((odd && output[0] < 0) || ((~odd) && output[0] > 0)) {
+        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
             if (output[0] > 0) {
                 output[0] -= Math.PI;
             } else {

package/src/core/geom/3d/mat4/m4_multiply_alphatensor.d.ts

@@ -7,5 +7,5 @@
  * @param {number[]|Float32Array} b
  * @returns {number[]|Float32Array} `out` parameter
  */
-export function m4_multiply_alphatensor(out: number[] | Float32Array, a: number[] | Float32Array, b: number[] | Float32Array): number[] | Float32Array;
+export function m4_multiply_alphatensor(out: number[] | Float32Array, a_in: any, b_in: any): number[] | Float32Array;
 //# sourceMappingURL=m4_multiply_alphatensor.d.ts.map

package/src/core/geom/3d/mat4/m4_multiply_alphatensor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_multiply_alphatensor.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply_alphatensor.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,6CALW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,EAAE,GAAC,YAAY,CA8IjC"}
+{"version":3,"file":"m4_multiply_alphatensor.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply_alphatensor.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,6CALW,MAAM,EAAE,GAAC,YAAY,yBAGnB,MAAM,EAAE,GAAC,YAAY,CAoJjC"}

package/src/core/geom/3d/mat4/m4_multiply_alphatensor.js

@@ -7,7 +7,13 @@
  * @param {number[]|Float32Array} b
  * @returns {number[]|Float32Array} `out` parameter
  */
-export function m4_multiply_alphatensor(out, a, b) {
+export function m4_multiply_alphatensor(out, a_in, b_in) {
+    // The AlphaTensor factorization transcribed below computes the transpose of (b_in * a_in). To return
+    // out = a_in * b_in we feed the operands swapped (the a* locals read b_in, the b* locals read a_in) and
+    // write each computed element to its transposed output slot.
+    const a = b_in;
+    const b = a_in;
+
     // read out matricies
     const a11 = a[0];
     const a13 = a[2];
@@ -112,38 +118,38 @@ export function m4_multiply_alphatensor(out, a, b) {
     const c14 = -h16 + h17 - h20 - h21 + h22 - h23 + h25 + h26 - h29 - h32 - h33 + h34 + h38 - h41 + h42 + h43
 
     out[0] = c11;
-    out[1] = c12;
-    out[2] = c13;
-    out[3] = c14;
+    out[4] = c12;
+    out[8] = c13;
+    out[12] = c14;
 
     const c21 = -h7 + h8 - h10 + h11 - h14 + h15 + h16 - h17 + h18 + h21 - h31 + h33 - h35 - h36
     const c22 = h7 - h8 + h10 - h11 - h15 - h16 + h17 - h18 - h21 + h22 - h23 + h26 - h33 + h44
     const c23 = -h7 + h8 + h11 + h12 - h16 + h17 - h20 - h21 - h29 - h33 + h34 + h36 + h38 + h46
     const c24 = -h7 + h8 + h11 + h12 - h16 + h17 - h20 - h21 + h22 - h23 + h25 + h26 - h29 - h33 + h34 + h38
 
-    out[4] = c21;
+    out[1] = c21;
     out[5] = c22;
-    out[6] = c23;
-    out[7] = c24;
+    out[9] = c23;
+    out[13] = c24;
 
     const c31 = h1 - h2 + h3 - h5 + h33 - h34 + h37 - h40
     const c32 = h17 - h18 - h19 - h21 - h23 + h24 + h26 - h33 + h34 - h37 + h40 - h43 + h44 + h45 - h47 + h49
     const c33 = h4 + h5 - h29 - h33 + h34 + h40
     const c34 = -h21 + h26 - h27 + h28 - h29 - h32 - h33 + h34 + h40 - h47
 
-    out[8] = c31;
-    out[9] = c32;
+    out[2] = c31;
+    out[6] = c32;
     out[10] = c33;
-    out[11] = c34;
+    out[14] = c34;
 
     const c41 = h8 - h10 + h11 - h13 + h17 - h18 - h19 - h21 + h31 - h33 + h34 + h35 + h36 - h37 - h39 + h40
     const c42 = -h8 + h10 - h11 + h13 - h17 + h18 + h19 + h21 + h23 - h24 - h26 + h33 - h34 + h37 - h40 - h44
     const c43 = h11 + h21 - h28 + h29 + h30 + h33 - h34 - h35 - h36 + h39 - h40 + h48
     const c44 = h11 + h21 - h26 + h27 - h28 + h29 + h33 - h34 - h40 + h48
 
-    out[12] = c41;
-    out[13] = c42;
-    out[14] = c43;
+    out[3] = c41;
+    out[7] = c42;
+    out[11] = c43;
     out[15] = c44;
 
     return out;

package/src/core/geom/3d/octahedra/octahedral_direction_to_uv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"octahedral_direction_to_uv.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/octahedra/octahedral_direction_to_uv.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,mDALW,MAAM,EAAE,cACR,MAAM,gBACN,MAAM,EAAE,aACR,MAAM,QAsChB"}
+{"version":3,"file":"octahedral_direction_to_uv.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/octahedra/octahedral_direction_to_uv.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,mDALW,MAAM,EAAE,cACR,MAAM,gBACN,MAAM,EAAE,aACR,MAAM,QAuChB"}

package/src/core/geom/3d/octahedra/octahedral_direction_to_uv.js

@@ -43,6 +43,7 @@ export function octahedral_direction_to_uv(
         octahedron_z = octant_z * (1 - absolute_x);
     }
 
-    out_uv[out_offset + 0] = octahedron_x;
-    out_uv[out_offset + 1] = octahedron_z;
+    // map octahedron coordinates from [-1,1] into [0,1] UV space; this exactly inverts the decode's `*2 - 1`.
+    out_uv[out_offset + 0] = octahedron_x * 0.5 + 0.5;
+    out_uv[out_offset + 1] = octahedron_z * 0.5 + 0.5;
 }

package/src/core/geom/3d/plane/plane3_compute_plane_intersection.js

@@ -64,13 +64,14 @@ function solveIntersectingPoint(zeroCoord, A, B, p1, p2, result) {
 
     const a1 = nP1[A];
     const b1 = nP1[B];
-    const d1 = p1.constant;
+    // plane equation is dot(normal, p) + constant = 0, so the linear-system RHS is -constant
+    const d1 = -p1.constant;
 
     const nP2 = p2.normal;
 
     const a2 = nP2[A];
     const b2 = nP2[B];
-    const d2 = p2.constant;
+    const d2 = -p2.constant;
 
     const A0 = ((b2 * d1) - (b1 * d2)) / ((a1 * b2 - a2 * b1));
     const B0 = ((a1 * d2) - (a2 * d1)) / ((a1 * b2 - a2 * b1));

package/src/{engine/physics/integration/quat_integrate.d.ts → core/geom/3d/quaternion/quat3_integrate.d.ts}

@@ -23,5 +23,5 @@
  * @param {number} omega_z
  * @param {number} dt
  */
-export function quat_integrate(result_q: number[] | Float64Array | Quaternion, qx: number, qy: number, qz: number, qw: number, omega_x: number, omega_y: number, omega_z: number, dt: number): void;
-//# sourceMappingURL=quat_integrate.d.ts.map
+export function quat3_integrate(result_q: number[] | Float64Array | Quaternion, qx: number, qy: number, qz: number, qw: number, omega_x: number, omega_y: number, omega_z: number, dt: number): void;
+//# sourceMappingURL=quat3_integrate.d.ts.map

package/src/core/geom/3d/quaternion/quat3_integrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_integrate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_integrate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0CAVW,MAAM,EAAE,GAAC,YAAY,aAAW,MAChC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,MACN,MAAM,QAsChB"}

package/src/{engine/physics/integration/quat_integrate.js → core/geom/3d/quaternion/quat3_integrate.js}

@@ -23,7 +23,7 @@
  * @param {number} omega_z
  * @param {number} dt
  */
-export function quat_integrate(
+export function quat3_integrate(
     result_q,
     qx, qy, qz, qw,
     omega_x, omega_y, omega_z,

package/src/core/geom/3d/shape/MeshShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/MeshShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAKQ;;;;;OAKG;IACH,WAFU,YAAY,CAEc;IAEpC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;;OAOG;IACH,UAFU,eAAe,CAEY;IAErC;;;;;;;;OAQG;IACH,eAFU,YAAY,CAEkB;IAExC;;;;;;OAMG;IACH,SAFU,GAAG,CAEW;IAExB;;;;;OAKG;IACH,eAAkD;IAElD;;;;;OAKG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,uBAAuB;IAW3B,wCAIC;IAED;;;;;OAKG;IACH,yBAmDC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,QA0BhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAkCnB;IAED;;;;;;;;;OASG;IACH,iCAHW,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,EAAE,GAAC,YAAY,QA4C/B;IAED;;;;;;;;OAQG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAsClB;IAED;;;;;;;;;OASG;IACH,sCAJW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,gBACK,MAAM,QAuB3B;IAED;;;;;;OAMG;IACH,0CAJW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAiBlB;IAED;;;;;;OAMG;IACH,cAHW,WAAW,GACT,OAAO,CAanB;IAkBL;;;;OAIG;IACH,wBAFU,OAAO,CAEkB;CAPlC;gCAje+B,sBAAsB;gCADtB,kCAAkC;oBAJ9C,2BAA2B"}
+{"version":3,"file":"MeshShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/MeshShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAKQ;;;;;OAKG;IACH,WAFU,YAAY,CAEc;IAEpC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;;OAOG;IACH,UAFU,eAAe,CAEY;IAErC;;;;;;;;OAQG;IACH,eAFU,YAAY,CAEkB;IAExC;;;;;;OAMG;IACH,SAFU,GAAG,CAEW;IAExB;;;;;OAKG;IACH,eAAkD;IAElD;;;;;OAKG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,uBAAuB;IAW3B,wCAIC;IAED;;;;;OAKG;IACH,yBAmDC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,QA0BhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAyCnB;IAED;;;;;;;;;OASG;IACH,iCAHW,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,EAAE,GAAC,YAAY,QA4C/B;IAED;;;;;;;;OAQG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAsClB;IAED;;;;;;;;;OASG;IACH,sCAJW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,gBACK,MAAM,QAuB3B;IAED;;;;;;OAMG;IACH,0CAJW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAiBlB;IAED;;;;;;OAMG;IACH,cAHW,WAAW,GACT,OAAO,CAanB;IAkBL;;;;OAIG;IACH,wBAFU,OAAO,CAEkB;CAPlC;gCAxe+B,sBAAsB;gCADtB,kCAAkC;oBAJ9C,2BAA2B"}

package/src/core/geom/3d/shape/MeshShape3D.js

@@ -273,6 +273,13 @@ export class MeshShape3D extends AbstractShape3D {
         scratch_query_aabb[0] = px; scratch_query_aabb[1] = py; scratch_query_aabb[2] = pz;
         scratch_query_aabb[3] = px; scratch_query_aabb[4] = py; scratch_query_aabb[5] = pz;
 
+        // Ensure the shared (module-static) candidate buffer can hold every possible hit. A single point can
+        // overlap at most `count` tet AABBs, so this is a guaranteed-safe upper bound; without it the query
+        // silently truncates at the fixed 64-slot size and contains_point can miss the containing tet.
+        if (scratch_candidates.length < this.tet_mesh.count) {
+            scratch_candidates = new Uint32Array(this.tet_mesh.count);
+        }
+
         const n = bvh_query_user_data_overlaps_aabb(
             scratch_candidates, 0, this.tet_bvh, scratch_query_aabb
         );

package/src/{engine/physics/narrowphase/PosedShape.d.ts → core/geom/3d/shape/PosedShape3D.d.ts}

@@ -5,11 +5,12 @@
  * query direction into body space, ask the shape, then rotate the support
  * point back to world.
  *
- * Existing TransformedShape3D solves a more general case (arbitrary matrix
- * including scale) and crucially does *not* rotate the query direction into
- * body space before calling support — that path is correct for unscaled
- * identity rotations but wrong for rotated bodies, which is what narrowphase
- * needs.
+ * Relationship to {@link TransformedShape3D}: that class solves the more
+ * general case (arbitrary affine matrix including scale) at the cost of
+ * storing a matrix pair and running a matrix inversion on every transform
+ * update. This class is the rigid-pose specialization for hot paths: no
+ * matrix is ever built, rebinding via {@link setup} is seven scalar copies,
+ * and `support` is pure inlined quaternion math.
  *
  * Reusable: physics narrowphase keeps two long-lived instances and calls
  * {@link setup} each pair. No per-pair allocation.
@@ -17,7 +18,7 @@
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export class PosedShape extends AbstractShape3D {
+export class PosedShape3D extends AbstractShape3D {
     /** @type {AbstractShape3D|null} */
     shape: AbstractShape3D | null;
     px: number;
@@ -47,5 +48,5 @@ export class PosedShape extends AbstractShape3D {
     }): void;
     compute_bounding_box(result: any): void;
 }
-import { AbstractShape3D } from "../../../core/geom/3d/shape/AbstractShape3D.js";
-//# sourceMappingURL=PosedShape.d.ts.map
+import { AbstractShape3D } from "./AbstractShape3D.js";
+//# sourceMappingURL=PosedShape3D.d.ts.map

package/src/{engine/physics/narrowphase/PosedShape.d.ts.map → core/geom/3d/shape/PosedShape3D.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"PosedShape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/PosedShape.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAKQ,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CACd;IAEjB,WAAW;IAAE,WAAW;IAAE,WAAW;IACrC,WAAW;IAAE,WAAW;IAAE,WAAW;IAAE,WAAW;IAGtD;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAM1D;IAgDD,wCASC;CACJ;gCA1G+B,gDAAgD"}
+{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAKQ,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CACd;IAEjB,WAAW;IAAE,WAAW;IAAE,WAAW;IACrC,WAAW;IAAE,WAAW;IAAE,WAAW;IAAE,WAAW;IAGtD;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAM1D;IAgDD,wCASC;CACJ;gCA3G+B,sBAAsB"}

package/src/{engine/physics/narrowphase/PosedShape.js → core/geom/3d/shape/PosedShape3D.js}

@@ -1,5 +1,5 @@
-import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
-import { AbstractShape3D } from "../../../core/geom/3d/shape/AbstractShape3D.js";
+import { aabb3_transform_oriented } from "../aabb/aabb3_transform_oriented.js";
+import { AbstractShape3D } from "./AbstractShape3D.js";
 
 const scratch_local = new Float64Array(3);
 const scratch_local_aabb = new Float64Array(6);
@@ -11,11 +11,12 @@ const scratch_local_aabb = new Float64Array(6);
  * query direction into body space, ask the shape, then rotate the support
  * point back to world.
  *
- * Existing TransformedShape3D solves a more general case (arbitrary matrix
- * including scale) and crucially does *not* rotate the query direction into
- * body space before calling support — that path is correct for unscaled
- * identity rotations but wrong for rotated bodies, which is what narrowphase
- * needs.
+ * Relationship to {@link TransformedShape3D}: that class solves the more
+ * general case (arbitrary affine matrix including scale) at the cost of
+ * storing a matrix pair and running a matrix inversion on every transform
+ * update. This class is the rigid-pose specialization for hot paths: no
+ * matrix is ever built, rebinding via {@link setup} is seven scalar copies,
+ * and `support` is pure inlined quaternion math.
  *
  * Reusable: physics narrowphase keeps two long-lived instances and calls
  * {@link setup} each pair. No per-pair allocation.
@@ -23,7 +24,7 @@ const scratch_local_aabb = new Float64Array(6);
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export class PosedShape extends AbstractShape3D {
+export class PosedShape3D extends AbstractShape3D {
 
     constructor() {
         super();
@@ -57,7 +58,7 @@ export class PosedShape extends AbstractShape3D {
      * @param {number} dz world-space query direction z
      */
     support(result, result_offset, dx, dy, dz) {
-        // Inline q·v·q* math: PosedShape.support is the hottest GJK call
+        // Inline q·v·q* math: PosedShape3D.support is the hottest GJK call
         // (twice per iteration of the body-level fallback, once per
         // triangle for concave dispatch). V8 declines to inline
         // v3_quat3_apply at 9-arg call sites, so the math is repeated

package/src/core/geom/3d/shape/TransformedShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAkBA;IA4CI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAclB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAW9B;IAjGG;;;;OAIG;IACH,iBAAoC;IAEpC;;;;OAIG;IACH,yBAA4C;IAE5C;;;;OAIG;IACH,kBAAqB;IAGzB;;;OAGG;IACH,+BAEC;IAuED;;;OAGG;IACH,4CAIC;IAED,yCAEC;IAUD,wCAKC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,qGAwCC;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;CAMJ;;8BAIS,OAAO;;gCAtRe,sBAAsB"}
+{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAwBA;IA4CI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAiBlB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAM9B;IA/FG;;;;OAIG;IACH,iBAAoC;IAEpC;;;;OAIG;IACH,yBAA4C;IAE5C;;;;OAIG;IACH,kBAAqB;IAGzB;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,4CAIC;IAED,yCAEC;IAUD,wCAKC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,qGAwCC;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;CAMJ;;8BAIS,OAAO;;gCA1Re,sBAAsB"}

package/src/core/geom/3d/shape/TransformedShape3D.js

@@ -1,4 +1,3 @@
-import { Transform } from "../../../../engine/ecs/transform/Transform.js";
 import { assert } from "../../../assert.js";
 import { isArrayEqualStrict } from "../../../collection/array/isArrayEqualStrict.js";
 import { computeHashFloatArray } from "../../../math/hash/computeHashFloatArray.js";
@@ -8,6 +7,7 @@ import { v3_matrix4_multiply } from "../../vec3/v3_matrix4_multiply.js";
 import { aabb3_matrix4_project } from "../aabb/aabb3_matrix4_project.js";
 import { m4_extract_scale } from "../mat4/m4_extract_scale.js";
 import { m4_invert } from "../mat4/m4_invert.js";
+import { m4_make_scale } from "../mat4/m4_make_scale.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 
 /**
@@ -16,6 +16,12 @@ import { AbstractShape3D } from "./AbstractShape3D.js";
  */
 const scratch_v3_0 = new Float32Array(3);
 
+/**
+ *
+ * @type {Float32Array|mat4}
+ */
+const scratch_m4_0 = new Float32Array(16);
+
 export class TransformedShape3D extends AbstractShape3D {
     constructor() {
         super();
@@ -88,11 +94,14 @@ export class TransformedShape3D extends AbstractShape3D {
         assert.isArrayLike(scale, 'scale');
         assert.greaterThanOrEqual(scale.length, 3, 'scale length must be >= 3');
 
-        const t = new Transform();
-        t.scale.fromArray(scale);
-        t.position.fromArray(translation);
+        // T·S: scale is applied in the subject's local frame, translation is not scaled
+        const m = m4_make_scale(scratch_m4_0, scale);
 
-        return TransformedShape3D.from_m4(subject, t.matrix);
+        m[12] = translation[0];
+        m[13] = translation[1];
+        m[14] = translation[2];
+
+        return TransformedShape3D.from_m4(subject, m);
     }
 
     /**
@@ -111,12 +120,7 @@ export class TransformedShape3D extends AbstractShape3D {
      * @param {number[]|Float32Array|vec3} scale
      */
     static from_scale(subject, scale) {
-
-        const t = new Transform();
-        t.scale.fromArray(scale);
-
-
-        return TransformedShape3D.from_m4(subject, t.matrix);
+        return TransformedShape3D.from_m4(subject, m4_make_scale(scratch_m4_0, scale));
     }
 
     /**

package/src/core/geom/3d/shape/UnionShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UnionShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/UnionShape3D.js"],"names":[],"mappings":"AA2BA;IAqII;;;;OAIG;IACH,sBAHW,eAAe,EAAE,GACf,YAAY,CAYxB;IAhJG;;;OAGG;IACH,UAFU,eAAe,EAAE,CAET;IAElB;;;;;OAKG;IACH,kCAAmC;IAEnC,qBAAsB;IACtB,qBAAuB;IACvB,uBAAyB;IAG7B,wCAgCC;IAED;;;OAGG;IACH,mCAkBC;IAED;;;OAGG;IACH,2CA8CC;IA2DD,mEAEC;IAED,6CAaC;IAED,oCAYC;IAED,kFAoDC;IAED,qGAyBC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;CAcJ;gCAxV+B,sBAAsB"}
+{"version":3,"file":"UnionShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/UnionShape3D.js"],"names":[],"mappings":"AA2BA;IAsII;;;;OAIG;IACH,sBAHW,eAAe,EAAE,GACf,YAAY,CAYxB;IAjJG;;;OAGG;IACH,UAFU,eAAe,EAAE,CAET;IAElB;;;;;OAKG;IACH,kCAAmC;IAEnC,qBAAsB;IACtB,qBAAuB;IACvB,uBAAyB;IAG7B,wCAgCC;IAED;;;OAGG;IACH,mCAkBC;IAED;;;OAGG;IACH,2CA+CC;IA2DD,mEAEC;IAED,6CAaC;IAED,oCAYC;IAED,kFAoDC;IAED,qGAyBC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;CAcJ;gCAzV+B,sBAAsB"}

package/src/core/geom/3d/shape/UnionShape3D.js

@@ -135,7 +135,7 @@ export class UnionShape3D extends AbstractShape3D {
 
             const child_0 = children[target_child_index];
 
-            for (j = 0; j < VOLUME_OVERLAP_ESTIMATION_SUB_TAPS; j++, i++) {
+            for (j = 0; j < VOLUME_OVERLAP_ESTIMATION_SUB_TAPS; j++) {
 
                 child_0.sample_random_point_in_volume(scratch_array, 0, random);
 
@@ -155,7 +155,8 @@ export class UnionShape3D extends AbstractShape3D {
             }
         }
 
-        this.__volume_overlap_fraction = tap_overlaps / (VOLUME_OVERLAP_ESTIMATION_TAPS);
+        // total samples taken = outer taps * sub-taps (the inner loop no longer corrupts the outer counter)
+        this.__volume_overlap_fraction = tap_overlaps / (VOLUME_OVERLAP_ESTIMATION_TAPS * VOLUME_OVERLAP_ESTIMATION_SUB_TAPS);
     }
 
     /**

package/src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shape3d_voxelize_to_grid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,gFAVW,YAAY,GAAC,MAAM,EAAE,iBAErB,YAAY,GAAC,MAAM,EAAE,QAErB,UAAU,MAEV,MAAM,MACN,MAAM,MACN,MAAM,QA6EhB"}
+{"version":3,"file":"shape3d_voxelize_to_grid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,gFAVW,YAAY,GAAC,MAAM,EAAE,iBAErB,YAAY,GAAC,MAAM,EAAE,QAErB,UAAU,MAEV,MAAM,MACN,MAAM,MACN,MAAM,QAkFhB"}