@woosh/meep-engine 3.20.0 → 3.21.0

package/src/engine/physics/fluid/effector/WakeFluidEffector.js

@@ -20,7 +20,7 @@ const scratch_b = new Float32Array(3);
  * Trail advancement (copying `position` into `previous_position`) depends on who
  * drives the effector:
  *
- *   - **Transform-managed** (entity has a `Transform`; {@link FluidSystem} calls
+ *   - **Transform64-managed** (entity has a `Transform64`; {@link FluidSystem} calls
  *     {@link syncFromTransform} once per fixed update): the trail advances inside
  *     the sync, NOT inside {@link apply}. The segment is "movement since the last
  *     tick", and `apply` is a pure read — the same instance can be applied to any
@@ -42,13 +42,13 @@ const scratch_b = new Float32Array(3);
  * effector picks the smallest physically meaningful footprint when the converted
  * radius is below one cell.
  *
- * When the entity carrying a {@link FluidEffectorsComponent} also has a Transform,
+ * When the entity carrying a {@link FluidEffectorsComponent} also has a Transform64,
  * {@link FluidSystem} calls {@link syncFromTransform} on this effector each step —
  * which pulls the latest world-space position off the transform. On the very first
  * sync `previous_position` is seeded equal to `position` to suppress the spurious
  * wake from `[0, 0, 0]`.
  *
- * For sources you position manually (no Transform on the entity, or no entity at
+ * For sources you position manually (no Transform64 on the entity, or no entity at
  * all), call {@link reset_trail} once after the initial placement and after any
  * teleport so the next apply doesn't splat a wake across the jump.
  */
@@ -56,7 +56,7 @@ export class WakeFluidEffector extends AbstractFluidEffector {
 
     /**
      * Current world-space position of the source. Updated each step from the entity
-     * Transform (via {@link syncFromTransform}) when one is available, otherwise set
+     * Transform64 (via {@link syncFromTransform}) when one is available, otherwise set
      * by user code before each step.
      * @type {[number, number, number]}
      */
@@ -98,7 +98,7 @@ export class WakeFluidEffector extends AbstractFluidEffector {
 
     /**
      * True once {@link syncFromTransform} has ever been called — the effector is
-     * driven by an entity Transform via {@link FluidSystem}. In this mode the
+     * driven by an entity Transform64 via {@link FluidSystem}. In this mode the
      * trail advances in the sync (once per tick) and {@link apply} becomes a pure
      * read, so one instance can serve any number of fluid fields per step.
      * @type {boolean}
@@ -119,7 +119,7 @@ export class WakeFluidEffector extends AbstractFluidEffector {
     }
 
     /**
-     * Pull world-space position off the entity Transform and advance the trail:
+     * Pull world-space position off the entity Transform64 and advance the trail:
      * `previous_position` takes the position adopted on the LAST sync, `position`
      * takes the transform's current one. Called by {@link FluidSystem} once per
      * fixed update, before any field is stepped — so every field stepped this
@@ -129,7 +129,7 @@ export class WakeFluidEffector extends AbstractFluidEffector {
      * `previous_position = position` instead, suppressing a wake from the origin
      * or across a teleport.
      *
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     syncFromTransform(transform) {
         const p = transform.translation;
@@ -328,7 +328,7 @@ export class WakeFluidEffector extends AbstractFluidEffector {
 
     /**
      * Manual-mode trail bookkeeping: shift `previous_position` to `position` so
-     * the next apply() picks up where this one left off. Transform-managed
+     * the next apply() picks up where this one left off. Transform64-managed
      * effectors skip this — their trail advances in {@link syncFromTransform},
      * keeping apply() pure so the same segment serves every field in the step.
      */

package/src/engine/physics/inertia/world_inverse_inertia.d.ts

@@ -3,7 +3,7 @@
  * vector and write the result.
  *
  * Body-frame inverse inertia is supplied as a diagonal in principal axes
- * (a Vector3-like with `.x .y .z`). World inverse inertia is
+ * (three elements, indexed `[0] [1] [2]`). World inverse inertia is
  * `I_w⁻¹ = R · diag · R^T` where `R` is the body's orientation. We compute
  * `result = R · diag · R^T · v` without materialising the full 3x3 matrix:
  *
@@ -17,35 +17,26 @@
  * Sphere short-circuit: if the inverse inertia is isotropic (ix === iy === iz),
  * the rotation cancels and `result = ix * v`. Skip the trig and save the work.
  *
- * Decoupled from RigidBody / Transform on purpose — callers pass only what
+ * Decoupled from RigidBody / Transform64 on purpose — callers pass only what
  * is actually read. Lets `compute_penetration` and other standalone
  * geometry helpers reuse this without manufacturing a body.
  *
  * @param {number[]|Float64Array} result length >= 3
  * @param {number} result_offset
- * @param {{x: number, y: number, z: number}} inv_inertia_local
- *        Body-frame inverse inertia diagonal (typically `rb.inverseInertiaLocal`).
- * @param {{x: number, y: number, z: number, w: number}} rotation
- *        Body orientation as a unit quaternion (typically `transform.rotation`).
+ * @param {number[]|Float64Array} inv_inertia_local
+ *        Body-frame inverse inertia diagonal, `[x, y, z]` (typically `rb.inverseInertiaLocal`).
+ * @param {number[]|Float64Array} rotation
+ *        Body orientation as a unit quaternion, `[x, y, z, w]` (typically `transform.rotation`).
  * @param {number} vx
  * @param {number} vy
  * @param {number} vz
  */
-export function world_inverse_inertia_apply(result: number[] | Float64Array, result_offset: number, inv_inertia_local: {
-    x: number;
-    y: number;
-    z: number;
-}, rotation: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}, vx: number, vy: number, vz: number): void;
+export function world_inverse_inertia_apply(result: number[] | Float64Array, result_offset: number, inv_inertia_local: number[] | Float64Array, rotation: number[] | Float64Array, vx: number, vy: number, vz: number): void;
 /**
  * Raw-float counterpart of {@link world_inverse_inertia_apply}: the same
  * `I_w⁻¹ = R · diag · R^T` application, with the inverse-inertia diagonal and
  * orientation quaternion passed as scalars rather than read off
- * `{x,y,z}` / `{x,y,z,w}` objects. The data-oriented contact / joint solver
+ * three- / four-element arrays. The data-oriented contact / joint solver
  * reads these straight out of its `SolverBodyState` typed array, avoiding the
  * per-impulse object dereference on the hot path. The arithmetic is identical
  * to the object version (same operation order), so results are bit-identical.

package/src/engine/physics/inertia/world_inverse_inertia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world_inverse_inertia.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/inertia/world_inverse_inertia.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,oDAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,qBACN;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,YAEjC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,MAE5C,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+CAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAgBlB;AAED,iLA0CC"}
+{"version":3,"file":"world_inverse_inertia.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/inertia/world_inverse_inertia.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,oDAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,qBACN,MAAM,EAAE,GAAC,YAAY,YAErB,MAAM,EAAE,GAAC,YAAY,MAErB,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+CAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAgBlB;AAED,iLA0CC"}

package/src/engine/physics/inertia/world_inverse_inertia.js

@@ -3,7 +3,7 @@
  * vector and write the result.
  *
  * Body-frame inverse inertia is supplied as a diagonal in principal axes
- * (a Vector3-like with `.x .y .z`). World inverse inertia is
+ * (three elements, indexed `[0] [1] [2]`). World inverse inertia is
  * `I_w⁻¹ = R · diag · R^T` where `R` is the body's orientation. We compute
  * `result = R · diag · R^T · v` without materialising the full 3x3 matrix:
  *
@@ -17,16 +17,16 @@
  * Sphere short-circuit: if the inverse inertia is isotropic (ix === iy === iz),
  * the rotation cancels and `result = ix * v`. Skip the trig and save the work.
  *
- * Decoupled from RigidBody / Transform on purpose — callers pass only what
+ * Decoupled from RigidBody / Transform64 on purpose — callers pass only what
  * is actually read. Lets `compute_penetration` and other standalone
  * geometry helpers reuse this without manufacturing a body.
  *
  * @param {number[]|Float64Array} result length >= 3
  * @param {number} result_offset
- * @param {{x: number, y: number, z: number}} inv_inertia_local
- *        Body-frame inverse inertia diagonal (typically `rb.inverseInertiaLocal`).
- * @param {{x: number, y: number, z: number, w: number}} rotation
- *        Body orientation as a unit quaternion (typically `transform.rotation`).
+ * @param {number[]|Float64Array} inv_inertia_local
+ *        Body-frame inverse inertia diagonal, `[x, y, z]` (typically `rb.inverseInertiaLocal`).
+ * @param {number[]|Float64Array} rotation
+ *        Body orientation as a unit quaternion, `[x, y, z, w]` (typically `transform.rotation`).
  * @param {number} vx
  * @param {number} vy
  * @param {number} vz
@@ -36,14 +36,14 @@ export function world_inverse_inertia_apply(
     inv_inertia_local, rotation,
     vx, vy, vz
 ) {
-    // Thin object-reading wrapper over the raw-float kernel. Reads the
-    // quaternion fields eagerly (harmless in the isotropic short-circuit,
+    // Thin array-reading wrapper over the raw-float kernel. Reads the
+    // quaternion elements eagerly (harmless in the isotropic short-circuit,
     // where they're ignored) so the kernel is the single source of the math —
-    // keeping object callers and the data-oriented (SoA) solver path
+    // keeping the component callers and the data-oriented (SoA) solver path
     // bit-identical.
     world_inverse_inertia_apply_raw(
         result, result_offset,
-        inv_inertia_local.x, inv_inertia_local.y, inv_inertia_local.z,
+        inv_inertia_local[0], inv_inertia_local[1], inv_inertia_local[2],
         rotation[0], rotation[1], rotation[2], rotation[3],
         vx, vy, vz
     );
@@ -53,7 +53,7 @@ export function world_inverse_inertia_apply(
  * Raw-float counterpart of {@link world_inverse_inertia_apply}: the same
  * `I_w⁻¹ = R · diag · R^T` application, with the inverse-inertia diagonal and
  * orientation quaternion passed as scalars rather than read off
- * `{x,y,z}` / `{x,y,z,w}` objects. The data-oriented contact / joint solver
+ * three- / four-element arrays. The data-oriented contact / joint solver
  * reads these straight out of its `SolverBodyState` typed array, avoiding the
  * per-impulse object dereference on the hot path. The arithmetic is identical
  * to the object version (same operation order), so results are bit-identical.

package/src/engine/physics/integration/integrate_position.d.ts

@@ -22,16 +22,15 @@
  *
  * Persistent linear / angular velocity is read from the data-oriented
  * {@link SolverBodyState} span (`ss` / `base`); the pose remains authoritative
- * on the `Transform` and is written through `.set()` so its onChanged
- * subscribers and the per-substep concave re-detection keep seeing the moved
- * pose. The integrated orientation is mirrored back into the solver state so
- * the next substep's impulse loop evaluates world inertia against the current
- * frame.
+ * on the `Transform64` and is written there as each substep runs, so the
+ * per-substep concave re-detection keeps seeing the moved pose. The integrated
+ * orientation is mirrored back into the solver state so the next substep's
+ * impulse loop evaluates world inertia against the current frame.
  *
  * @param {Float64Array} ss solver-body-state data array
  * @param {number} base `body_index * SBS_STRIDE`
  * @param {RigidBody} rb
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} dt
  * @param {number} ps_lin_x pseudo-linear-velocity x (0 when no contacts)
  * @param {number} ps_lin_y
@@ -40,5 +39,5 @@
  * @param {number} ps_ang_y
  * @param {number} ps_ang_z
  */
-export function integrate_position(ss: Float64Array, base: number, rb: RigidBody, transform: Transform, dt: number, ps_lin_x: number, ps_lin_y: number, ps_lin_z: number, ps_ang_x: number, ps_ang_y: number, ps_ang_z: number): void;
+export function integrate_position(ss: Float64Array, base: number, rb: RigidBody, transform: Transform64, dt: number, ps_lin_x: number, ps_lin_y: number, ps_lin_z: number, ps_ang_x: number, ps_ang_y: number, ps_ang_z: number): void;
 //# sourceMappingURL=integrate_position.d.ts.map

package/src/engine/physics/integration/integrate_position.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrate_position.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_position.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,uCAZW,YAAY,QACZ,MAAM,2CAGN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,QA+ChB"}
+{"version":3,"file":"integrate_position.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_position.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,uCAZW,YAAY,QACZ,MAAM,6CAGN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,QA+ChB"}

package/src/engine/physics/integration/integrate_position.js

@@ -32,16 +32,15 @@ const scratch_q = new Float64Array(4);
  *
  * Persistent linear / angular velocity is read from the data-oriented
  * {@link SolverBodyState} span (`ss` / `base`); the pose remains authoritative
- * on the `Transform` and is written through `.set()` so its onChanged
- * subscribers and the per-substep concave re-detection keep seeing the moved
- * pose. The integrated orientation is mirrored back into the solver state so
- * the next substep's impulse loop evaluates world inertia against the current
- * frame.
+ * on the `Transform64` and is written there as each substep runs, so the
+ * per-substep concave re-detection keeps seeing the moved pose. The integrated
+ * orientation is mirrored back into the solver state so the next substep's
+ * impulse loop evaluates world inertia against the current frame.
  *
  * @param {Float64Array} ss solver-body-state data array
  * @param {number} base `body_index * SBS_STRIDE`
  * @param {RigidBody} rb
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} dt
  * @param {number} ps_lin_x pseudo-linear-velocity x (0 when no contacts)
  * @param {number} ps_lin_y

package/src/engine/physics/integration/integrate_velocity.d.ts

@@ -15,13 +15,13 @@
  * user / animation system's responsibility.
  *
  * @param {RigidBody} rb
- * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {Transform64} transform  used to rotate body-frame inertia into world
  * @param {number} gx world gravity x
  * @param {number} gy world gravity y
  * @param {number} gz world gravity z
  * @param {number} dt step size in seconds
  */
-export function integrate_velocity(rb: RigidBody, transform: Transform, gx: number, gy: number, gz: number, dt: number): void;
+export function integrate_velocity(rb: RigidBody, transform: Transform64, gx: number, gy: number, gz: number, dt: number): void;
 /**
  * Apply the accumulated force / torque to velocity over a step `dt`, then
  * zero the accumulators. Gravity and damping are NOT applied here.
@@ -32,10 +32,10 @@ export function integrate_velocity(rb: RigidBody, transform: Transform, gx: numb
  * by {@link integrate_velocity_gravity}.
  *
  * @param {RigidBody} rb
- * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {Transform64} transform  used to rotate body-frame inertia into world
  * @param {number} dt full outer-step size in seconds
  */
-export function integrate_velocity_forces(rb: RigidBody, transform: Transform, dt: number): void;
+export function integrate_velocity_forces(rb: RigidBody, transform: Transform64, dt: number): void;
 /**
  * Apply gravity and velocity damping over a (sub)step `dt`. Does NOT touch
  * the force / torque accumulators (consumed once by

package/src/engine/physics/integration/integrate_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrate_velocity.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_velocity.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,4EALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoDhB;AAED;;;;;;;;;;;;GAYG;AACH,mFAFW,MAAM,QAkDhB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CARW,YAAY,QACZ,MAAM,qBAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkChB"}
+{"version":3,"file":"integrate_velocity.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_velocity.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8EALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoDhB;AAED;;;;;;;;;;;;GAYG;AACH,qFAFW,MAAM,QAkDhB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CARW,YAAY,QACZ,MAAM,qBAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkChB"}

package/src/engine/physics/integration/integrate_velocity.js

@@ -9,20 +9,20 @@ const scratch_angular = new Float64Array(3);
 // axis has infinite effective inertia, so a torque produces no angular
 // acceleration about it — the same masking the solver gather and applyImpulseAt
 // apply, applied here so the torque/force accumulator path can't spin a locked DOF.
-const scratch_locked_inertia = { x: 0, y: 0, z: 0 };
+const scratch_locked_inertia = new Float64Array(3);
 
 /**
  * @param {RigidBody} rb
- * @returns {{x:number,y:number,z:number}} the shared {@link scratch_locked_inertia}, filled with
+ * @returns {Float64Array} the shared {@link scratch_locked_inertia}, filled with
  *   `rb.inverseInertiaLocal` masked by the body's LockRot* flags.
  */
 function locked_inverse_inertia(rb) {
     const flags = rb.flags;
     const ii = rb.inverseInertiaLocal;
 
-    scratch_locked_inertia.x = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii.x;
-    scratch_locked_inertia.y = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii.y;
-    scratch_locked_inertia.z = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii.z;
+    scratch_locked_inertia[0] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii[0];
+    scratch_locked_inertia[1] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii[1];
+    scratch_locked_inertia[2] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii[2];
 
     return scratch_locked_inertia;
 }
@@ -44,7 +44,7 @@ function locked_inverse_inertia(rb) {
  * user / animation system's responsibility.
  *
  * @param {RigidBody} rb
- * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {Transform64} transform  used to rotate body-frame inertia into world
  * @param {number} gx world gravity x
  * @param {number} gy world gravity y
  * @param {number} gz world gravity z
@@ -112,7 +112,7 @@ export function integrate_velocity(rb, transform, gx, gy, gz, dt) {
  * by {@link integrate_velocity_gravity}.
  *
  * @param {RigidBody} rb
- * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {Transform64} transform  used to rotate body-frame inertia into world
  * @param {number} dt full outer-step size in seconds
  */
 export function integrate_velocity_forces(rb, transform, dt) {

package/src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.d.ts

@@ -1,13 +1,13 @@
 /**
- * Note that bones are defined as a combination of Joint ({@link Transform}) and bone length. Joint defines the origin of the bone.
- * Last joint's position is expected to be bone_length distance from the target if target is reachable and be oriented towards that target ({@link Transform.lookAt})
- * @param {Transform[]} joints Will be updated as a result of the solve
+ * Note that bones are defined as a combination of Joint ({@link Transform64}) and bone length. Joint defines the origin of the bone.
+ * Last joint's position is expected to be bone_length distance from the target if target is reachable and be oriented towards that target ({@link Transform64#lookAt})
+ * @param {Transform64[]} joints Will be updated as a result of the solve
  * @param {number[]} lengths distance to next bone, bone lengths.
  * @param {Vector3} origin where should the first joint be placed at
  * @param {Vector3} target where should the last joint be placed at
  * @param {number} [max_iterations] More steps will lead to higher accuracy, but at the cost of computation. Generally solution will be reached in just a few iteration so this is just a ceiling
  * @param {number} [distance_tolerance] Minimum squared distance to be achieved to the target, used to terminate earlier before maximum number of iterations is reached
  */
-export function fabrik_solve(joints: Transform[], lengths: number[], origin: Vector3, target: Vector3, max_iterations?: number, distance_tolerance?: number): void;
+export function fabrik_solve(joints: Transform64[], lengths: number[], origin: Vector3, target: Vector3, max_iterations?: number, distance_tolerance?: number): void;
 import Vector3 from "../../../../core/geom/Vector3.js";
 //# sourceMappingURL=fabrik_solve.d.ts.map

package/src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fabrik_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.js"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AACH,qCAPW,WAAW,WACX,MAAM,EAAE,UACR,OAAO,UACP,OAAO,mBACP,MAAM,uBACN,MAAM,QAgGhB;oBApHmB,kCAAkC"}
+{"version":3,"file":"fabrik_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.js"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AACH,qCAPW,aAAa,WACb,MAAM,EAAE,UACR,OAAO,UACP,OAAO,mBACP,MAAM,uBACN,MAAM,QAgGhB;oBApHmB,kCAAkC"}

package/src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.js

@@ -12,9 +12,9 @@ const scratch_v3_1 = new Vector3();
 const scratch_quat = new Quaternion();
 
 /**
- * Note that bones are defined as a combination of Joint ({@link Transform}) and bone length. Joint defines the origin of the bone.
- * Last joint's position is expected to be bone_length distance from the target if target is reachable and be oriented towards that target ({@link Transform.lookAt})
- * @param {Transform[]} joints Will be updated as a result of the solve
+ * Note that bones are defined as a combination of Joint ({@link Transform64}) and bone length. Joint defines the origin of the bone.
+ * Last joint's position is expected to be bone_length distance from the target if target is reachable and be oriented towards that target ({@link Transform64#lookAt})
+ * @param {Transform64[]} joints Will be updated as a result of the solve
  * @param {number[]} lengths distance to next bone, bone lengths.
  * @param {Vector3} origin where should the first joint be placed at
  * @param {Vector3} target where should the last joint be placed at

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

@@ -1 +1 @@
-{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH;YAFsB,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC;SAAO,GAAG;EAmHlI;AAED;;;;;;;;;;;;;GAaG;AACH,gCAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAElC,IAAI,MAAM,EAAE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,CAAC;cAE9B,YAAY;kBAAgB,WAAW;gBAAc,WAAW;UAAQ,YAAY;EAgG3G;AAzPD,kCAAiF;oBAvC7D,gCAAgC"}
+{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH,oEAFa;IAAC,MAAM,EAAE,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC,CAAC;IAAC,GAAG,EAAE,GAAG,CAAA;CAAC,CAmHnI;AAED;;;;;;;;;;;;;GAaG;AACH,gCAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAElC,IAAI,MAAM,EAAE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,CAAC,GAEzC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAC,CAgG5G;AAzPD,kCAAiF;oBAvC7D,gCAAgC"}

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

@@ -20,8 +20,7 @@
  * manifold cache uses it as the warm-start match key.
  *
  * Stride 10 (rather than 9) is the small cost we pay for clean warm-start
- * matching; see the discussion in PLAN.md's "Pair-key → slot map" section
- * for why ID-based matching beats position-distance matching when shapes
+ * matching; ID-based matching beats position-distance matching when shapes
  * slide along curved surfaces.
  *
  * @readonly

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

@@ -1 +1 @@
-{"version":3,"file":"triangle_buffer_layout.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B"}
+{"version":3,"file":"triangle_buffer_layout.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B"}

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

@@ -20,8 +20,7 @@
  * manifold cache uses it as the warm-start match key.
  *
  * Stride 10 (rather than 9) is the small cost we pay for clean warm-start
- * matching; see the discussion in PLAN.md's "Pair-key → slot map" section
- * for why ID-based matching beats position-distance matching when shapes
+ * matching; ID-based matching beats position-distance matching when shapes
  * slide along curved surfaces.
  *
  * @readonly

package/src/engine/physics/narrowphase/narrowphase_step.d.ts

@@ -57,14 +57,14 @@ export function deepest_pair_penetration(out_normal: Float64Array | number[], sh
  *
  * @param {PairList} pair_list
  * @param {ManifoldStore} manifolds
- * @param {Array<Array<{collider: Collider, transform: Transform}>>} lists
+ * @param {Array<Array<{collider: Collider, transform: Transform64}>>} lists
  *   per-body collider lists, indexed by body-storage slot index. Typically
  *   `system.__body_collider_lists` — passed in directly so this helper
  *   has no dependency on `PhysicsSystem`.
  */
 export function narrowphase_step(pair_list: PairList, manifolds: ManifoldStore, lists: Array<Array<{
     collider: Collider;
-    transform: Transform;
+    transform: Transform64;
 }>>): void;
 /**
  * Re-detect contact GEOMETRY for one existing manifold slot at the bodies'
@@ -89,14 +89,15 @@ export function narrowphase_step(pair_list: PairList, manifolds: ManifoldStore,
  *
  * @param {ManifoldStore} manifolds
  * @param {number} slot
- * @param {Array<{collider: Collider, transform: Transform}>} list_a
- * @param {Array<{collider: Collider, transform: Transform}>} list_b
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_a
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_b
  */
 export function redetect_pair_geometry(manifolds: ManifoldStore, slot: number, list_a: Array<{
     collider: Collider;
-    transform: Transform;
+    transform: Transform64;
 }>, list_b: Array<{
     collider: Collider;
-    transform: Transform;
+    transform: Transform64;
 }>): void;
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 //# sourceMappingURL=narrowphase_step.d.ts.map

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,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"}
+{"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,EAAE,WAAW,CAAA;CAAC,CAAC,CAAC,QA4LpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,UACnD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,QA2H7D;4BAptD2B,oCAAoC"}

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

@@ -97,7 +97,7 @@ const MAX_KEPT = MAX_CONTACTS_PER_MANIFOLD;
  * contact has no feature id (or none of the previous-frame contacts shares
  * its id), match by closest world_a within this 3-D distance.
  *
- * 2 cm matches the original PLAN.md spec for "Persistent manifold cache"
+ * 2 cm matches the original plan spec for "Persistent manifold cache"
  * — generous enough to follow small inter-frame contact migration on
  * curved surfaces, tight enough that distinct contacts on a single
  * manifold (typically >5 cm apart) don't get confused with each other.
@@ -378,9 +378,9 @@ function sphere_box_voronoi_fid(sx, sy, sz, bx, by, bz, bqx, bqy, bqz, bqw, hx,
  *
  * @param {number} count
  * @param {{vertices,face_offsets,face_loops,support}} hullA  in A's local frame
- * @param {Transform} trA
+ * @param {Transform64} trA
  * @param {{vertices,face_offsets,face_loops,support}} hullB  in B's local frame
- * @param {Transform} trB
+ * @param {Transform64} trB
  * @param {Function} append_contact
  * @returns {number}
  */
@@ -427,9 +427,9 @@ function hull_pair_contacts(count, hullA, trA, hullB, trB, append_contact) {
  *
  * @param {number} count
  * @param {Collider} colA
- * @param {Transform} trA
+ * @param {Transform64} trA
  * @param {Collider} colB
- * @param {Transform} trB
+ * @param {Transform64} trB
  * @returns {number}
  */
 function dispatch_pair(count, colA, trA, colB, trB) {
@@ -1443,7 +1443,7 @@ export function deepest_pair_penetration(out_normal, shapeA, posA, rotA, shapeB,
  *
  * @param {PairList} pair_list
  * @param {ManifoldStore} manifolds
- * @param {Array<Array<{collider: Collider, transform: Transform}>>} lists
+ * @param {Array<Array<{collider: Collider, transform: Transform64}>>} lists
  *   per-body collider lists, indexed by body-storage slot index. Typically
  *   `system.__body_collider_lists` — passed in directly so this helper
  *   has no dependency on `PhysicsSystem`.
@@ -1656,8 +1656,8 @@ export function narrowphase_step(pair_list, manifolds, lists) {
  *
  * @param {ManifoldStore} manifolds
  * @param {number} slot
- * @param {Array<{collider: Collider, transform: Transform}>} list_a
- * @param {Array<{collider: Collider, transform: Transform}>} list_b
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_a
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_b
  */
 export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
     if (list_a === undefined || list_b === undefined) return;

package/src/engine/physics/queries/PhysicsSurfacePoint.d.ts

@@ -13,6 +13,12 @@
  * GC per call. Reusing the same `PhysicsSurfacePoint` keeps that allocation
  * out of the hot path.
  *
+ * For the same reason `position` and `normal` are raw three-element
+ * `Float64Array`s indexed `[0] [1] [2]`, not `Vector3`: a change signal on a
+ * result the queries overwrite on every call is two allocations and a dispatch
+ * nobody subscribes to. Write them with {@link v3_set} — `array.set(x, y, z)`
+ * is `TypedArray.prototype.set`, which silently writes nothing.
+ *
  * Field layout chosen to match what gameplay code typically needs:
  *   - `position` — world-space point on the surface
  *   - `normal` — surface normal at that point (broadphase queries return
@@ -34,17 +40,17 @@ export class PhysicsSurfacePoint {
     /**
      * World-space point on the hit surface.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly position: Vector3;
+    readonly position: Float64Array;
     /**
      * Surface normal at {@link position}, unit length. For broadphase-only
      * queries this is the AABB face normal (axis-aligned), which is exact
      * for AABB-shaped colliders and a stable approximation otherwise.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly normal: Vector3;
+    readonly normal: Float64Array;
     /**
      * Parametric distance from the query origin to {@link position}, in
      * the same units as the input direction's magnitude (so for a unit-
@@ -79,5 +85,4 @@ export class PhysicsSurfacePoint {
      */
     readonly isPhysicsSurfacePoint: boolean;
 }
-import Vector3 from "../../../core/geom/Vector3.js";
 //# sourceMappingURL=PhysicsSurfacePoint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PhysicsSurfacePoint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/PhysicsSurfacePoint.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAEI;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;;;OAMG;IACH,iBAFU,OAAO,CAEM;IAEvB;;;;;OAKG;IACH,GAFU,MAAM,CAEV;IAEN;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;;OAMG;IACH,cAQC;IAGL;;;;OAIG;IACH,gCAFU,OAAO,CAEkC;CAPlD;oBA1FmB,+BAA+B"}
+{"version":3,"file":"PhysicsSurfacePoint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/PhysicsSurfacePoint.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAEI;;;;OAIG;IACH,mBAFU,YAAY,CAES;IAE/B;;;;;;OAMG;IACH,iBAFU,YAAY,CAEO;IAE7B;;;;;OAKG;IACH,GAFU,MAAM,CAEV;IAEN;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;;OAMG;IACH,cAQC;IAGL;;;;OAIG;IACH,gCAFU,OAAO,CAEkC;CAPlD"}

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

@@ -1,5 +1,3 @@
-import Vector3 from "../../../core/geom/Vector3.js";
-
 /**
  * Result of a {@link PhysicsSystem} query that resolves to a single surface
  * contact — raycast hit, sphere overlap nearest-point, shape-cast first
@@ -15,6 +13,12 @@ import Vector3 from "../../../core/geom/Vector3.js";
  * GC per call. Reusing the same `PhysicsSurfacePoint` keeps that allocation
  * out of the hot path.
  *
+ * For the same reason `position` and `normal` are raw three-element
+ * `Float64Array`s indexed `[0] [1] [2]`, not `Vector3`: a change signal on a
+ * result the queries overwrite on every call is two allocations and a dispatch
+ * nobody subscribes to. Write them with {@link v3_set} — `array.set(x, y, z)`
+ * is `TypedArray.prototype.set`, which silently writes nothing.
+ *
  * Field layout chosen to match what gameplay code typically needs:
  *   - `position` — world-space point on the surface
  *   - `normal` — surface normal at that point (broadphase queries return
@@ -37,18 +41,18 @@ export class PhysicsSurfacePoint {
     /**
      * World-space point on the hit surface.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    position = new Vector3();
+    position = new Float64Array(3);
 
     /**
      * Surface normal at {@link position}, unit length. For broadphase-only
      * queries this is the AABB face normal (axis-aligned), which is exact
      * for AABB-shaped colliders and a stable approximation otherwise.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    normal = new Vector3();
+    normal = new Float64Array(3);
 
     /**
      * Parametric distance from the query origin to {@link position}, in

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

@@ -26,10 +26,10 @@
  * @param {PhysicsSystem} system
  * @param {AbstractShape3D} shape  query shape, convex; expressed in
  *   its own local frame
- * @param {{x:number,y:number,z:number}} position world position of the
- *   query shape
- * @param {{x:number,y:number,z:number,w:number}} rotation world rotation
- *   of the query shape (unit quaternion)
+ * @param {number[]|Float64Array} position world position of the query shape,
+ *   indexed as [x, y, z]
+ * @param {number[]|Float64Array} rotation world rotation of the query shape
+ *   (unit quaternion), indexed as [x, y, z, w]
  * @param {Uint32Array|number[]} output buffer to write body_ids into.
  *   Caller is responsible for sizing it; ids past its end are dropped.
  * @param {number} output_offset float-index in output to start writing at
@@ -38,14 +38,5 @@
  * @returns {number} number of overlapping bodies written
  * @throws {Error} if `shape.is_convex === false`
  */
-export function overlap_shape(system: PhysicsSystem, shape: AbstractShape3D, position: {
-    x: number;
-    y: number;
-    z: number;
-}, rotation: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}, output: Uint32Array | number[], output_offset: number, filter?: (entity: number, collider: Collider) => boolean): number;
+export function overlap_shape(system: PhysicsSystem, shape: AbstractShape3D, position: number[] | Float64Array, rotation: number[] | Float64Array, output: Uint32Array | number[], output_offset: number, filter?: (entity: number, collider: Collider) => boolean): number;
 //# sourceMappingURL=overlap_shape.d.ts.map

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,CAmHlB"}
+{"version":3,"file":"overlap_shape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/overlap_shape.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAZW,MAAM,EAAE,GAAC,YAAY,YAErB,MAAM,EAAE,GAAC,YAAY,UAErB,WAAW,GAAC,MAAM,EAAE,iBAEpB,MAAM,WACN,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,UAAS,KAAG,OAAO,GAEzC,MAAM,CAmHlB"}