@woosh/meep-engine 3.19.0 → 3.21.0

package/src/engine/physics/body/SolverBodyState.js

@@ -10,9 +10,9 @@ import { SleepState } from "../ecs/SleepState.js";
  * integration) reads and writes a small, fixed set of per-body quantities
  * thousands of times per step: linear / angular velocity, inverse mass,
  * inverse-inertia diagonal, and orientation. In the object world those live on
- * the {@link RigidBody} and {@link Transform} *components*, reached via
+ * the {@link RigidBody} and {@link Transform64} *components*, reached via
  * `system.__bodies[idx]` / `system.__transforms[idx]` — a chain of pointer
- * dereferences (array → component object → `Vector3` field) on the hottest
+ * dereferences (array → component object → `Float64Array` field) on the hottest
  * inner loop in the engine.
  *
  * This class packs exactly those quantities into one ArrayBuffer-backed,
@@ -34,10 +34,10 @@ import { SleepState } from "../ecs/SleepState.js";
  *  - {@link scatter} once at the end: write the persistent linear / angular
  *    velocity back to each gathered body's `RigidBody`. Pose is NOT scattered
  *    here — `integrate_position` keeps the authoritative pose on the
- *    `Transform` (write-through, so its `onChanged` subscribers and the
- *    per-substep concave re-detection still see the moved pose); the
- *    orientation quaternion is mirrored into `data` purely for the impulse
- *    loop's world-inverse-inertia evaluation.
+ *    `Transform64` (written through as the substep runs, so the per-substep
+ *    concave re-detection still sees the moved pose); the orientation
+ *    quaternion is mirrored into `data` purely for the impulse loop's
+ *    world-inverse-inertia evaluation.
  *
  * ## Material content
  *
@@ -157,7 +157,7 @@ export class SolverBodyState {
      *
      * @param {number} idx body slot index
      * @param {RigidBody} rb
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     gather(idx, rb, transform) {
         const stamp = this.__stamp;
@@ -190,9 +190,9 @@ export class SolverBodyState {
             // themselves when locking a body mid-spin.
             const ii = rb.inverseInertiaLocal;
             const flags = rb.flags;
-            d[base + SBS_INV_I_X] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii.x;
-            d[base + SBS_INV_I_Y] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii.y;
-            d[base + SBS_INV_I_Z] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii.z;
+            d[base + SBS_INV_I_X] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii[0];
+            d[base + SBS_INV_I_Y] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii[1];
+            d[base + SBS_INV_I_Z] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii[2];
         } else {
             // Static / Kinematic: immovable to the solver — no inverse mass,
             // no inverse inertia (mirrors the object path's `kind` guards).
@@ -221,9 +221,9 @@ export class SolverBodyState {
 
     /**
      * Write the solved persistent linear / angular velocity back onto every
-     * gathered body's `RigidBody`. Direct typed-array writes into the
-     * `Vector3` backing — the same observer-bypassing path the solver already
-     * uses for velocity (`lv[0] += …`), so no `onChanged` semantics change.
+     * gathered body's `RigidBody`. The velocity fields are raw `Float64Array`s,
+     * so this is a plain typed-array store — the same path the solver already
+     * uses for velocity (`lv[0] += …`).
      *
      * @param {RigidBody[]} bodies sparse, indexed by slot
      */

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts

@@ -5,9 +5,9 @@
  * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
  * @param {AbstractShape3D} shape
- * @param {Transform} transform
+ * @param {Transform64} transform
  */
-export function compute_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform): void;
+export function compute_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform64): void;
 /**
  * Inflate a world AABB in place: a symmetric constant slack plus a
  * DIRECTIONAL velocity pad — each axis extends only toward where the body is
@@ -31,11 +31,11 @@ export function fatten_world_aabb(aabb: number[] | Float32Array | Float64Array,
  * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
  * @param {AbstractShape3D} shape
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} vx world linear velocity x
  * @param {number} vy world linear velocity y
  * @param {number} vz world linear velocity z
  * @param {number} dt step size
  */
-export function compute_fat_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform, vx: number, vy: number, vz: number, dt: number): void;
+export function compute_fat_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform64, vx: number, vy: number, vz: number, dt: number): void;
 //# sourceMappingURL=compute_fat_world_aabb.d.ts.map

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,sDAiBhB;AAED;;;;;;;;;;;;;GAaG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB;AAED;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,oDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}
+{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,wDAiBhB;AAED;;;;;;;;;;;;;GAaG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB;AAED;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,sDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}

package/src/engine/physics/broadphase/compute_fat_world_aabb.js

@@ -28,7 +28,7 @@ const FAT_VELOCITY_MULTIPLIER = 2;
  * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
  * @param {AbstractShape3D} shape
- * @param {Transform} transform
+ * @param {Transform64} transform
  */
 export function compute_world_aabb(result, result_offset, shape, transform) {
     shape.compute_bounding_box(scratch_local);
@@ -81,7 +81,7 @@ export function fatten_world_aabb(aabb, offset, vx, vy, vz, dt) {
  * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
  * @param {AbstractShape3D} shape
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} vx world linear velocity x
  * @param {number} vy world linear velocity y
  * @param {number} vz world linear velocity z

package/src/engine/physics/broadphase/generate_pairs.d.ts

@@ -25,7 +25,7 @@
  * @param {BVH} dynamic_bvh
  * @param {BVH} static_bvh
  * @param {ManifoldStore} manifolds
- * @param {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>} body_collider_lists
+ * @param {Array<Array<{collider: Collider, transform: Transform64, entity: number, bvhNode: number}>>} body_collider_lists
  * @param {PairList} pair_list_out cleared and filled
  * @param {((idA: number, idB: number) => boolean) | null} pair_filter optional
  *        gate. Returning `false` rejects the pair entirely — no manifold
@@ -36,8 +36,8 @@
  */
 export function generate_pairs(storage: BodyStorage, dynamic_bvh: BVH, static_bvh: BVH, manifolds: ManifoldStore, body_collider_lists: Array<Array<{
     collider: Collider;
-    transform: Transform;
+    transform: Transform64;
     entity: number;
     bvhNode: number;
-}>>, pair_list_out: PairList, pair_filter?: (idA: number, idB: number) => boolean, pair_filter_this_arg?: any): void;
+}>>, pair_list_out: PairList, pair_filter?: ((idA: number, idB: number) => boolean) | null, pair_filter_this_arg?: any): void;
 //# sourceMappingURL=generate_pairs.d.ts.map

package/src/engine/physics/broadphase/generate_pairs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uIATW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,+CAElF,MAAM,OAAO,MAAM,KAAK,OAAO,oCA+FhD"}
+{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uIATW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,cAAc;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,yCAE3F,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,IAAI,oCA+FxD"}

package/src/engine/physics/broadphase/generate_pairs.js

@@ -39,7 +39,7 @@ let candidates = new Uint32Array(1024);
  * @param {BVH} dynamic_bvh
  * @param {BVH} static_bvh
  * @param {ManifoldStore} manifolds
- * @param {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>} body_collider_lists
+ * @param {Array<Array<{collider: Collider, transform: Transform64, entity: number, bvhNode: number}>>} body_collider_lists
  * @param {PairList} pair_list_out cleared and filled
  * @param {((idA: number, idB: number) => boolean) | null} pair_filter optional
  *        gate. Returning `false` rejects the pair entirely — no manifold

package/src/engine/physics/ccd/linear_sweep.d.ts

@@ -54,7 +54,7 @@ export function ccd_release_contacts(system: import("../ecs/PhysicsSystem.js").P
  *
  * Start-of-step positions are captured into `system.__ccd_start_pos` (3 doubles
  * per body index) before the substep loop; this pass reads the final pose from
- * the live Transform.
+ * the live Transform64.
  *
  * Bodies are processed in ENTITY order, not awake-list order. CCD order is
  * outcome-coupled: an earlier body's clamp moves the pose a later body's
@@ -68,8 +68,7 @@ export function ccd_release_contacts(system: import("../ecs/PhysicsSystem.js").P
  */
 export function ccd_resolve(system: import("../ecs/PhysicsSystem.js").PhysicsSystem): void;
 /**
- * Continuous collision detection — linear shape-cast (the "speculative margin
- * floor, upgraded to an opt-in per-body sweep" item from PLAN.md).
+ * Continuous collision detection — linear shape-cast.
  *
  * The discrete pipeline detects contacts by overlap at step boundaries: a body
  * that moves more than its own thickness in one step can start a step on one

package/src/engine/physics/ccd/linear_sweep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AAgKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAdW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA2ClB;AA2ID;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAsHzD;AA3gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCAtDP,mCAAmC"}
+{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AA+JA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAdW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA2ClB;AA2ID;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAsHzD;AA1gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCArDP,mCAAmC"}

package/src/engine/physics/ccd/linear_sweep.js

@@ -8,8 +8,7 @@ import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
 import { shape_cast } from "../queries/shape_cast.js";
 
 /**
- * Continuous collision detection — linear shape-cast (the "speculative margin
- * floor, upgraded to an opt-in per-body sweep" item from PLAN.md).
+ * Continuous collision detection — linear shape-cast.
  *
  * The discrete pipeline detects contacts by overlap at step boundaries: a body
  * that moves more than its own thickness in one step can start a step on one
@@ -69,7 +68,7 @@ export const CCD_MIN_SWEEP_DISTANCE = 1e-3;
  * and funnelling the f64 sweep endpoints through f32 quantises them (~1 mm at
  * |coord| ≈ 10⁴, ~16 mm at 10⁵) — visible TOI jitter far from the world
  * origin. {@link shape_cast} reads only the named accessors, so a ray-like
- * object preserves the Transform's full f64 precision end to end.
+ * object preserves the Transform64's full f64 precision end to end.
  */
 const _ray = {
     origin_x: 0, origin_y: 0, origin_z: 0,
@@ -286,7 +285,7 @@ export function ccd_sweep_segment(
  * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
  * @param {number} body_idx swept body's storage index
  * @param {Collider} collider the swept (primary) collider
- * @param {Transform} tr the swept body's transform, already clamped to the
+ * @param {Transform64} tr the swept body's transform, already clamped to the
  *   contact pose
  * @param {PhysicsSurfacePoint} hit the sweep result that produced the clamp
  */
@@ -402,7 +401,7 @@ export function ccd_release_contacts(system) {
  *
  * Start-of-step positions are captured into `system.__ccd_start_pos` (3 doubles
  * per body index) before the substep loop; this pass reads the final pose from
- * the live Transform.
+ * the live Transform64.
  *
  * Bodies are processed in ENTITY order, not awake-list order. CCD order is
  * outcome-coupled: an earlier body's clamp moves the pose a later body's

package/src/engine/physics/constraint/solve_constraints.js

@@ -595,7 +595,7 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
 
         // World anchor A and its lever arm rA = R_A · localAnchorA.
         const la = joint.localAnchorA;
-        v3_quaternion_apply(scratch_anchor, 0, la.x, la.y, la.z,
+        v3_quaternion_apply(scratch_anchor, 0, la[0], la[1], la[2],
             trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w);
         const rAx = scratch_anchor[0], rAy = scratch_anchor[1], rAz = scratch_anchor[2];
         const anchorAx = trA.translation_x + rAx;
@@ -608,9 +608,9 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
         let anchorBx, anchorBy, anchorBz;
         const lb = joint.localAnchorB;
         if (to_world) {
-            anchorBx = lb.x; anchorBy = lb.y; anchorBz = lb.z;
+            anchorBx = lb[0]; anchorBy = lb[1]; anchorBz = lb[2];
         } else {
-            v3_quaternion_apply(scratch_anchor, 0, lb.x, lb.y, lb.z,
+            v3_quaternion_apply(scratch_anchor, 0, lb[0], lb[1], lb[2],
                 trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w);
             rBx = scratch_anchor[0]; rBy = scratch_anchor[1]; rBz = scratch_anchor[2];
             anchorBx = trB.translation_x + rBx;

package/src/engine/physics/ecs/BodyKind.d.ts

@@ -10,7 +10,7 @@
  *      RESERVED, not yet implemented: per-step velocity derivation is NOT
  *      performed, so pose-driven movers currently present to the solver as
  *      stationary walls that teleport. (Deriving velocity implicitly from
- *      Transform deltas is deliberately deferred — without a separate
+ *      Transform64 deltas is deliberately deferred — without a separate
  *      move/teleport API a spawn snap would read as an enormous velocity and
  *      explode contacts. Prefer KinematicVelocity for movers until then.)
  *

package/src/engine/physics/ecs/BodyKind.js

@@ -10,7 +10,7 @@
  *      RESERVED, not yet implemented: per-step velocity derivation is NOT
  *      performed, so pose-driven movers currently present to the solver as
  *      stationary walls that teleport. (Deriving velocity implicitly from
- *      Transform deltas is deliberately deferred — without a separate
+ *      Transform64 deltas is deliberately deferred — without a separate
  *      move/teleport API a spawn snap would read as an enormous velocity and
  *      explode contacts. Prefer KinematicVelocity for movers until then.)
  *

package/src/engine/physics/ecs/Collider.d.ts

@@ -9,7 +9,7 @@ export const COLLIDER_UNBOUND: number;
  * Collider component.
  *
  * Pairs a shared, immutable {@link AbstractShape3D} with a body-specific surface
- * material. World pose comes from the entity's own {@link Transform}; for compound
+ * material. World pose comes from the entity's own {@link Transform64}; for compound
  * bodies the child collider entities are linked to the body via the existing
  * `ParentEntity` component.
  *

package/src/engine/physics/ecs/Collider.js

@@ -15,7 +15,7 @@ export const COLLIDER_UNBOUND = -1;
  * Collider component.
  *
  * Pairs a shared, immutable {@link AbstractShape3D} with a body-specific surface
- * material. World pose comes from the entity's own {@link Transform}; for compound
+ * material. World pose comes from the entity's own {@link Transform64}; for compound
  * bodies the child collider entities are linked to the body via the existing
  * `ParentEntity` component.
  *

package/src/engine/physics/ecs/Joint.d.ts

@@ -25,6 +25,13 @@ export const JOINT_WORLD: number;
  * `localAnchorB` is interpreted as a fixed **world** point instead of a
  * local anchor on a second body.
  *
+ * The anchors and basis frames are raw `Float64Array`s — three elements indexed
+ * `[0] [1] [2]` for x, y, z, four elements `[0]..[3]` for x, y, z, w. They are plain
+ * storage with no change signal, matching {@link RigidBody}'s vectors, and the joint
+ * solver reads them by index every substep. Write them with {@link v3_set} /
+ * {@link v4_set}: `array.set(x, y, z)` is `TypedArray.prototype.set`, which silently
+ * writes nothing.
+ *
  * Solver state ({@link dofImpulse}, the `_*` fields) is owned by the
  * PhysicsSystem; user code must not write it.
  *
@@ -45,16 +52,16 @@ export class Joint {
     /**
      * Anchor point on body A, in A's local frame.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly localAnchorA: Vector3;
+    readonly localAnchorA: Float64Array;
     /**
      * Anchor point on body B in B's local frame — or, when
      * `entityB === JOINT_WORLD`, a fixed world-space anchor point.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly localAnchorB: Vector3;
+    readonly localAnchorB: Float64Array;
     /**
      * Orientation of the joint's reference frame on body A, in A's local
      * space (a unit quaternion; identity = the joint frame is the body
@@ -63,18 +70,18 @@ export class Joint {
      * hinge, the free angular axis is one of these frame axes — orient the
      * frame so that axis is the hinge axis.
      * @readonly
-     * @type {Quaternion}
+     * @type {Float64Array}
      */
-    readonly localBasisA: Quaternion;
+    readonly localBasisA: Float64Array;
     /**
      * Orientation of the joint's reference frame on body B, in B's local
      * space. At rest a fully-locked joint holds frame B aligned to frame A.
      * When `entityB === JOINT_WORLD`, the world frame is treated as identity
      * (angular locks hold A's frame to world axes).
      * @readonly
-     * @type {Quaternion}
+     * @type {Float64Array}
      */
-    readonly localBasisB: Quaternion;
+    readonly localBasisB: Float64Array;
     /**
      * Per-DOF mode, 6 entries: `[lin x, lin y, lin z, ang x, ang y, ang z]`.
      * Default = ball-socket (linear locked, angular free).
@@ -310,6 +317,4 @@ export class Joint {
 export namespace Joint {
     let typeName: string;
 }
-import Vector3 from "../../../core/geom/Vector3.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
 //# sourceMappingURL=Joint.d.ts.map

package/src/engine/physics/ecs/Joint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Joint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/Joint.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,0BAFU,MAAM,CAEc;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;OAGG;IACH,SAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,uBAFU,OAAO,CAEmB;IAEpC;;;;;OAKG;IACH,uBAFU,OAAO,CAEmB;IAEpC;;;;;;;;;OASG;IACH,sBAFU,UAAU,CAEW;IAE/B;;;;;;;OAOG;IACH,sBAFU,UAAU,CAEW;IAE/B;;;;;OAKG;IACH,kBAFU,UAAU,CAKjB;IAEH;;;;;;;;;;OAUG;IACH,YAFU,OAAO,CAEE;IAEnB;;;;;;OAMG;IACH,wBAFU,YAAY,CAEc;IACpC,qCAAqC;IACrC,wBADqB,YAAY,CACG;IAEpC;;;;;OAKG;IACH,uBAFU,YAAY,CAEa;IACnC,qCAAqC;IACrC,qBADqB,YAAY,CACA;IAEjC;;;;;OAKG;IACH,iCAFU,YAAY,CAEuB;IAC7C,qCAAqC;IACrC,2BADqB,YAAY,CACM;IAEvC;;;;;OAKG;IACH,qBAFU,YAAY,CAEW;IAEjC;;;OAGG;IACH,UAFU,MAAM,CAEF;IACd;;;OAGG;IACH,UAFU,MAAM,CAEO;IACvB;;;OAGG;IACH,UAFU,MAAM,CAEa;IAE7B;;;;;OAKG;IACH,gBAFa,KAAK,CAUjB;IAED;;;;OAIG;IACH,UAFa,KAAK,CAKjB;IAED;;;;;;;;OAQG;IACH,0BAJW,MAAM,GAEJ,KAAK,CAWjB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,GAEJ,KAAK,CAWjB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,wBAPW,MAAM,cACN,MAAM,eACN,MAAM,gBACN,MAAM,GAEJ,KAAK,CAiBjB;IAED;;;;;;;;;;OAUG;IACH,qBANW,MAAM,SACN,MAAM,SAEN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBALW,MAAM,SACN,MAAM,SACN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;;;OAYG;IACH,qBAPW,MAAM,kBACN,MAAM,YAEN,MAAM,GAEJ,KAAK,CAOjB;IAED;;;;;;;;;;;;;;OAcG;IACH,sBATW,MAAM,kBACN,MAAM,YAIN,MAAM,GAEJ,KAAK,CAOjB;IAED;;;;;;;;;;;OAWG;IACH,sBALW,MAAM,aACN,MAAM,WACN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;;;OAYG;IACH,uBANW,MAAM,aACN,MAAM,WAEN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;OAUG;IACH,cAHW,KAAK,GACH,OAAO,CA+BnB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAsBlB;IASL;;;OAGG;IACH,kBAFU,OAAO,CAEM;CAZtB;;kBAIS,MAAM;;oBAjdI,+BAA+B;uBAC5B,kCAAkC"}
+{"version":3,"file":"Joint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/Joint.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,0BAFU,MAAM,CAEc;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAEI;;;OAGG;IACH,SAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,uBAFU,YAAY,CAEa;IAEnC;;;;;OAKG;IACH,uBAFU,YAAY,CAEa;IAEnC;;;;;;;;;OASG;IACH,sBAFU,YAAY,CAEoB;IAE1C;;;;;;;OAOG;IACH,sBAFU,YAAY,CAEoB;IAE1C;;;;;OAKG;IACH,kBAFU,UAAU,CAKjB;IAEH;;;;;;;;;;OAUG;IACH,YAFU,OAAO,CAEE;IAEnB;;;;;;OAMG;IACH,wBAFU,YAAY,CAEc;IACpC,qCAAqC;IACrC,wBADqB,YAAY,CACG;IAEpC;;;;;OAKG;IACH,uBAFU,YAAY,CAEa;IACnC,qCAAqC;IACrC,qBADqB,YAAY,CACA;IAEjC;;;;;OAKG;IACH,iCAFU,YAAY,CAEuB;IAC7C,qCAAqC;IACrC,2BADqB,YAAY,CACM;IAEvC;;;;;OAKG;IACH,qBAFU,YAAY,CAEW;IAEjC;;;OAGG;IACH,UAFU,MAAM,CAEF;IACd;;;OAGG;IACH,UAFU,MAAM,CAEO;IACvB;;;OAGG;IACH,UAFU,MAAM,CAEa;IAE7B;;;;;OAKG;IACH,gBAFa,KAAK,CAUjB;IAED;;;;OAIG;IACH,UAFa,KAAK,CAKjB;IAED;;;;;;;;OAQG;IACH,0BAJW,MAAM,GAEJ,KAAK,CAWjB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,GAEJ,KAAK,CAWjB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,wBAPW,MAAM,cACN,MAAM,eACN,MAAM,gBACN,MAAM,GAEJ,KAAK,CAiBjB;IAED;;;;;;;;;;OAUG;IACH,qBANW,MAAM,SACN,MAAM,SAEN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBALW,MAAM,SACN,MAAM,SACN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;;;OAYG;IACH,qBAPW,MAAM,kBACN,MAAM,YAEN,MAAM,GAEJ,KAAK,CAOjB;IAED;;;;;;;;;;;;;;OAcG;IACH,sBATW,MAAM,kBACN,MAAM,YAIN,MAAM,GAEJ,KAAK,CAOjB;IAED;;;;;;;;;;;OAWG;IACH,sBALW,MAAM,aACN,MAAM,WACN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;;;OAYG;IACH,uBANW,MAAM,aACN,MAAM,WAEN,MAAM,GACJ,KAAK,CAOjB;IAED;;;;;;;;;;OAUG;IACH,cAHW,KAAK,GACH,OAAO,CA+BnB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAsBlB;IASL;;;OAGG;IACH,kBAFU,OAAO,CAEM;CAZtB;;kBAIS,MAAM"}

package/src/engine/physics/ecs/Joint.js

@@ -1,6 +1,8 @@
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
+import { v3_equals_array } from "../../../core/geom/vec3/v3_equals_array.js";
+import { v3_hash } from "../../../core/geom/vec3/v3_hash.js";
+import { v4_equals_array } from "../../../core/geom/vec4/v4_equals_array.js";
+import { v4_hash } from "../../../core/geom/vec4/v4_hash.js";
 import { DofMode } from "../constraint/DofMode.js";
 
 /**
@@ -32,6 +34,13 @@ export const JOINT_WORLD = -1;
  * `localAnchorB` is interpreted as a fixed **world** point instead of a
  * local anchor on a second body.
  *
+ * The anchors and basis frames are raw `Float64Array`s — three elements indexed
+ * `[0] [1] [2]` for x, y, z, four elements `[0]..[3]` for x, y, z, w. They are plain
+ * storage with no change signal, matching {@link RigidBody}'s vectors, and the joint
+ * solver reads them by index every substep. Write them with {@link v3_set} /
+ * {@link v4_set}: `array.set(x, y, z)` is `TypedArray.prototype.set`, which silently
+ * writes nothing.
+ *
  * Solver state ({@link dofImpulse}, the `_*` fields) is owned by the
  * PhysicsSystem; user code must not write it.
  *
@@ -55,17 +64,17 @@ export class Joint {
     /**
      * Anchor point on body A, in A's local frame.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    localAnchorA = new Vector3(0, 0, 0);
+    localAnchorA = new Float64Array(3);
 
     /**
      * Anchor point on body B in B's local frame — or, when
      * `entityB === JOINT_WORLD`, a fixed world-space anchor point.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    localAnchorB = new Vector3(0, 0, 0);
+    localAnchorB = new Float64Array(3);
 
     /**
      * Orientation of the joint's reference frame on body A, in A's local
@@ -75,9 +84,9 @@ export class Joint {
      * hinge, the free angular axis is one of these frame axes — orient the
      * frame so that axis is the hinge axis.
      * @readonly
-     * @type {Quaternion}
+     * @type {Float64Array}
      */
-    localBasisA = new Quaternion();
+    localBasisA = Float64Array.of(0, 0, 0, 1);
 
     /**
      * Orientation of the joint's reference frame on body B, in B's local
@@ -85,9 +94,9 @@ export class Joint {
      * When `entityB === JOINT_WORLD`, the world frame is treated as identity
      * (angular locks hold A's frame to world axes).
      * @readonly
-     * @type {Quaternion}
+     * @type {Float64Array}
      */
-    localBasisB = new Quaternion();
+    localBasisB = Float64Array.of(0, 0, 0, 1);
 
     /**
      * Per-DOF mode, 6 entries: `[lin x, lin y, lin z, ang x, ang y, ang z]`.
@@ -410,10 +419,10 @@ export class Joint {
         if (this.entityA !== other.entityA
             || this.entityB !== other.entityB
             || this.swingTwist !== other.swingTwist
-            || !this.localAnchorA.equals(other.localAnchorA)
-            || !this.localAnchorB.equals(other.localAnchorB)
-            || !this.localBasisA.equals(other.localBasisA)
-            || !this.localBasisB.equals(other.localBasisB)
+            || !v3_equals_array(this.localAnchorA, 0, other.localAnchorA, 0)
+            || !v3_equals_array(this.localAnchorB, 0, other.localAnchorB, 0)
+            || !v4_equals_array(this.localBasisA, 0, other.localBasisA, 0)
+            || !v4_equals_array(this.localBasisB, 0, other.localBasisB, 0)
         ) {
             return false;
         }
@@ -443,10 +452,10 @@ export class Joint {
         let h = this.entityA | 0;
         h = (h * 31 + (this.entityB | 0)) | 0;
         h = (h * 31 + (this.swingTwist ? 1 : 0)) | 0;
-        h = (h * 31 + this.localAnchorA.hash()) | 0;
-        h = (h * 31 + this.localAnchorB.hash()) | 0;
-        h = (h * 31 + this.localBasisA.hash()) | 0;
-        h = (h * 31 + this.localBasisB.hash()) | 0;
+        h = (h * 31 + v3_hash(this.localAnchorA, 0)) | 0;
+        h = (h * 31 + v3_hash(this.localAnchorB, 0)) | 0;
+        h = (h * 31 + v4_hash(this.localBasisA, 0)) | 0;
+        h = (h * 31 + v4_hash(this.localBasisB, 0)) | 0;
 
         for (let i = 0; i < 6; i++) {
             h = (h * 31 + (this.dofMode[i] | 0)) | 0;

package/src/engine/physics/ecs/JointSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JointSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/JointSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH;;IAEI,oBAAc;IAGd;;;OAGG;IACH,uCAFW,KAAK,QAwBf;IAED;;;OAGG;IACH,yCAFW,KAAK,QAqBf;CACJ;gDAvE+C,6DAA6D;sBACvF,YAAY"}
+{"version":3,"file":"JointSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/JointSerializationAdapter.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH;;IAEI,oBAAc;IAGd;;;OAGG;IACH,uCAFW,KAAK,QAwBf;IAED;;;OAGG;IACH,yCAFW,KAAK,QAqBf;CACJ;gDAvE+C,6DAA6D;sBACvF,YAAY"}

package/src/engine/physics/ecs/JointSerializationAdapter.js

@@ -1,3 +1,5 @@
+import { v3_set } from "../../../core/geom/vec3/v3_set.js";
+import { v4_set } from "../../../core/geom/vec4/v4_set.js";
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { Joint } from "./Joint.js";
 
@@ -27,8 +29,8 @@ export class JointSerializationAdapter extends BinaryClassSerializationAdapter {
         buffer.writeInt32(value.entityB);
 
         const la = value.localAnchorA, lb = value.localAnchorB;
-        buffer.writeFloat64(la.x); buffer.writeFloat64(la.y); buffer.writeFloat64(la.z);
-        buffer.writeFloat64(lb.x); buffer.writeFloat64(lb.y); buffer.writeFloat64(lb.z);
+        buffer.writeFloat64(la[0]); buffer.writeFloat64(la[1]); buffer.writeFloat64(la[2]);
+        buffer.writeFloat64(lb[0]); buffer.writeFloat64(lb[1]); buffer.writeFloat64(lb[2]);
 
         const ba = value.localBasisA, bb = value.localBasisB;
         buffer.writeFloat64(ba[0]); buffer.writeFloat64(ba[1]); buffer.writeFloat64(ba[2]); buffer.writeFloat64(ba[3]);
@@ -53,11 +55,11 @@ export class JointSerializationAdapter extends BinaryClassSerializationAdapter {
         value.entityA = buffer.readInt32();
         value.entityB = buffer.readInt32();
 
-        value.localAnchorA.set(buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
-        value.localAnchorB.set(buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
+        v3_set(value.localAnchorA, 0, buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
+        v3_set(value.localAnchorB, 0, buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
 
-        value.localBasisA.set(buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
-        value.localBasisB.set(buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
+        v4_set(value.localBasisA, 0, buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
+        v4_set(value.localBasisB, 0, buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64(), buffer.readFloat64());
 
         for (let i = 0; i < 6; i++) value.dofMode[i] = buffer.readUint8();
         for (let i = 0; i < 6; i++) value.dofLowerLimit[i] = buffer.readFloat64();