@woosh/meep-engine 3.19.0 → 3.21.0

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

@@ -24,6 +24,8 @@ import { solve_joints } from "../constraint/solve_constraints.js";
 import { ManifoldStore } from "../contact/ManifoldStore.js";
 import { ContactEventBuffer, ContactEventKind } from "../events/ContactEventBuffer.js";
 import { diff_manifolds } from "../events/diff_manifolds.js";
+import { v3_add } from "../../../core/geom/vec3/v3_add.js";
+import { v3_set } from "../../../core/geom/vec3/v3_set.js";
 import { world_inverse_inertia_apply } from "../inertia/world_inverse_inertia.js";
 import { integrate_position } from "../integration/integrate_position.js";
 import { integrate_velocity_forces, integrate_velocity_gravity } from "../integration/integrate_velocity.js";
@@ -60,9 +62,9 @@ const scratch_angular_delta = new Float64Array(3);
 /**
  * Scratch for {@link applyImpulseAt}'s LockRot*-masked inverse-inertia
  * diagonal (the same mask {@link SolverBodyState#gather} applies).
- * @type {{x: number, y: number, z: number}}
+ * @type {Float64Array}
  */
-const scratch_locked_inertia = { x: 0, y: 0, z: 0 };
+const scratch_locked_inertia = new Float64Array(3);
 
 /**
  * Reusable scratch buffer for world-AABB construction so the link path is
@@ -104,7 +106,7 @@ const scratch_prox_sleeper = new Float64Array(6);
 /**
  * Rigid-body physics system.
  *
- * v1 scope: pool + active list + two BVHs (static / dynamic), Transform sync
+ * v1 scope: pool + active list + two BVHs (static / dynamic), Transform64 sync
  * contract, and the user-facing API surface (gravity, force / impulse, layer
  * filtering, wake / sleep, contact filter). The per-step simulation pipeline
  * (broadphase pair generation, narrowphase, solver, islands, sleep test,
@@ -185,7 +187,7 @@ export class PhysicsSystem extends System {
      * Data-oriented mirror of the per-body solver hot state (velocity,
      * inverse mass / inertia, orientation), packed into one ArrayBuffer
      * and indexed by body slot. Gathered from the `RigidBody` /
-     * `Transform` components once per step (after islands are built),
+     * `Transform64` components once per step (after islands are built),
      * mutated in place by the TGS substep loop, and the persistent
      * velocity scattered back at the end. Keeps the solver's hottest inner
      * loop free of component-object dereferences.
@@ -250,7 +252,8 @@ export class PhysicsSystem extends System {
     contactDampingRatio = 10;
 
     /**
-     * Reusable contact-event payload. Listeners must copy any fields they
+     * Reusable contact-event payload. `point` and `normal` are three-element
+     * `Float64Array`s indexed `[0] [1] [2]`. Listeners must copy any fields they
      * intend to retain past their own scope. Reset before each dispatch.
      * @private
      */
@@ -259,16 +262,19 @@ export class PhysicsSystem extends System {
         entityB: -1,
         kind: 0,
         depth: 0,
-        normal: new Vector3(),
-        point: new Vector3(),
+        normal: new Float64Array(3),
+        point: new Float64Array(3),
     };
 
     /**
-     * World gravity, m/s². Applied each step scaled by per-body gravityScale.
+     * World gravity, m/s², indexed `[0] [1] [2]`. Applied each step scaled by the
+     * per-body gravityScale. Raw storage with no change signal — write it through
+     * {@link setGravity}, or with {@link v3_set} if the wake side-effect is not
+     * wanted; `gravity.set(x, y, z)` is `TypedArray.prototype.set` and writes nothing.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    gravity = new Vector3(0, -9.81, 0);
+    gravity = Float64Array.of(0, -9.81, 0);
 
     /**
      * Optional global contact filter. Called for each surviving broadphase
@@ -294,12 +300,12 @@ export class PhysicsSystem extends System {
 
     /**
      * Per-body list of attached colliders. Each entry stores the
-     * Collider component, its world Transform, the entity that owns
+     * Collider component, its world Transform64, the entity that owns
      * it (the body entity for same-entity attachments, a child entity
      * for compound bodies), and the BVH leaf id assigned at attach
      * time. A body may have zero or more attached colliders.
      *
-     * @type {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>}
+     * @type {Array<Array<{collider: Collider, transform: Transform64, entity: number, bvhNode: number}>>}
      */
     __body_collider_lists = [];
 
@@ -504,10 +510,15 @@ export class PhysicsSystem extends System {
 
     /**
      * Replace the world gravity vector. Effective on the next step.
-     * @param {Vector3|{x:number,y:number,z:number}} v
+     * @param {Vector3|ArrayLike<number>} v indexed as [x, y, z]
      */
     setGravity(v) {
-        this.gravity.set(v.x, v.y, v.z);
+        assert.defined(v, 'v');
+        assert.isNumber(v[0], 'v[0]');
+        assert.isNumber(v[1], 'v[1]');
+        assert.isNumber(v[2], 'v[2]');
+
+        v3_set(this.gravity, 0, v[0], v[1], v[2]);
     }
 
     /**
@@ -725,8 +736,8 @@ export class PhysicsSystem extends System {
      * Attach a collider to an existing body. The collider can live on the
      * same entity as the body (single-collider body) or on a child entity
      * (compound body). The world transform passed here is the collider's
-     * own — for a same-entity collider it is the body's Transform; for a
-     * child collider it is the child entity's Transform.
+     * own — for a same-entity collider it is the body's Transform64; for a
+     * child collider it is the child entity's Transform64.
      *
      * Idempotent — re-attaching the same collider is a no-op.
      *
@@ -902,14 +913,19 @@ export class PhysicsSystem extends System {
      * Wakes the body if it is asleep.
      *
      * @param {RigidBody} rigidBody
-     * @param {Vector3|{x:number,y:number,z:number}} impulse
+     * @param {Vector3|ArrayLike<number>} impulse indexed as [x, y, z]
      */
     applyImpulse(rigidBody, impulse) {
+        assert.defined(impulse, 'impulse');
+        assert.isNumber(impulse[0], 'impulse[0]');
+        assert.isNumber(impulse[1], 'impulse[1]');
+        assert.isNumber(impulse[2], 'impulse[2]');
+
         if (rigidBody.kind !== BodyKind.Dynamic) {
             return;
         }
         const inv_m = rigidBody.mass > 0 ? 1 / rigidBody.mass : 0;
-        rigidBody.linearVelocity.addScaled(impulse, inv_m);
+        v3_add(rigidBody.linearVelocity, 0, impulse[0] * inv_m, impulse[1] * inv_m, impulse[2] * inv_m);
 
         this.__wake_body(rigidBody);
     }
@@ -922,8 +938,8 @@ export class PhysicsSystem extends System {
      * Wakes the body if it is asleep.
      *
      * @param {RigidBody} rigidBody
-     * @param {Transform64} transform body's current world Transform (used for r and I_w)
-     * @param {Vector3|{x:number,y:number,z:number}} impulse
+     * @param {Transform64} transform body's current world transform (used for r and I_w)
+     * @param {Vector3|ArrayLike<number>} impulse indexed as [x, y, z]
      * @param {Vector3|ArrayLike<number>} worldPoint world-space point indexed as [x, y, z]
      */
     applyImpulseAt(
@@ -945,19 +961,15 @@ export class PhysicsSystem extends System {
 
         const inv_m = rigidBody.mass > 0 ? 1 / rigidBody.mass : 0;
 
-        const impulse_x = impulse.x;
-        const impulse_y = impulse.y;
-        const impulse_z = impulse.z;
+        const impulse_x = impulse[0];
+        const impulse_y = impulse[1];
+        const impulse_z = impulse[2];
 
-        assert.isNumber(impulse_x, 'impulse_x');
-        assert.isNumber(impulse_y, 'impulse_y');
-        assert.isNumber(impulse_z, 'impulse_z');
+        assert.isNumber(impulse_x, 'impulse[0]');
+        assert.isNumber(impulse_y, 'impulse[1]');
+        assert.isNumber(impulse_z, 'impulse[2]');
 
-        rigidBody.linearVelocity.set(
-            rigidBody.linearVelocity.x + impulse_x * inv_m,
-            rigidBody.linearVelocity.y + impulse_y * inv_m,
-            rigidBody.linearVelocity.z + impulse_z * inv_m
-        );
+        v3_add(rigidBody.linearVelocity, 0, impulse_x * inv_m, impulse_y * inv_m, impulse_z * inv_m);
 
         // World points use indexed coordinates, including Transform64 translation views.
         const rx = worldPoint[0] - transform.translation_x;
@@ -974,15 +986,14 @@ export class PhysicsSystem extends System {
         // DOF either.
         const flags = rigidBody.flags;
         const ii = rigidBody.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];
         world_inverse_inertia_apply(scratch_angular_delta, 0, scratch_locked_inertia, transform.rotation, tx, ty, tz);
 
-        rigidBody.angularVelocity.set(
-            rigidBody.angularVelocity.x + scratch_angular_delta[0],
-            rigidBody.angularVelocity.y + scratch_angular_delta[1],
-            rigidBody.angularVelocity.z + scratch_angular_delta[2]
+        v3_add(
+            rigidBody.angularVelocity, 0,
+            scratch_angular_delta[0], scratch_angular_delta[1], scratch_angular_delta[2]
         );
 
         this.__wake_body(rigidBody);
@@ -995,17 +1006,18 @@ export class PhysicsSystem extends System {
      * Wakes the body if asleep.
      *
      * @param {RigidBody} rigidBody
-     * @param {Vector3|{x:number,y:number,z:number}} torque
+     * @param {Vector3|ArrayLike<number>} torque indexed as [x, y, z]
      */
     applyTorque(rigidBody, torque) {
+        assert.defined(torque, 'torque');
+        assert.isNumber(torque[0], 'torque[0]');
+        assert.isNumber(torque[1], 'torque[1]');
+        assert.isNumber(torque[2], 'torque[2]');
+
         if (rigidBody.kind !== BodyKind.Dynamic) {
             return;
         }
-        rigidBody.accumulatedTorque.set(
-            rigidBody.accumulatedTorque.x + torque.x,
-            rigidBody.accumulatedTorque.y + torque.y,
-            rigidBody.accumulatedTorque.z + torque.z
-        );
+        v3_add(rigidBody.accumulatedTorque, 0, torque[0], torque[1], torque[2]);
         this.__wake_body(rigidBody);
     }
 
@@ -1017,11 +1029,16 @@ export class PhysicsSystem extends System {
      * Wakes the body if asleep.
      *
      * @param {RigidBody} rigidBody
-     * @param {Transform64} transform body's current world Transform
-     * @param {Vector3|{x:number,y:number,z:number}} force
+     * @param {Transform64} transform body's current world transform
+     * @param {Vector3|ArrayLike<number>} force indexed as [x, y, z]
      * @param {Vector3|ArrayLike<number>} worldPoint world-space point indexed as [x, y, z]
      */
     applyForceAt(rigidBody, transform, force, worldPoint) {
+        assert.defined(force, 'force');
+        assert.isNumber(force[0], 'force[0]');
+        assert.isNumber(force[1], 'force[1]');
+        assert.isNumber(force[2], 'force[2]');
+
         assert.defined(worldPoint, 'worldPoint');
         assert.isNumber(worldPoint[0], 'worldPoint[0]');
         assert.isNumber(worldPoint[1], 'worldPoint[1]');
@@ -1030,21 +1047,18 @@ export class PhysicsSystem extends System {
         if (rigidBody.kind !== BodyKind.Dynamic) {
             return;
         }
-        rigidBody.accumulatedForce.set(
-            rigidBody.accumulatedForce.x + force.x,
-            rigidBody.accumulatedForce.y + force.y,
-            rigidBody.accumulatedForce.z + force.z
-        );
+        v3_add(rigidBody.accumulatedForce, 0, force[0], force[1], force[2]);
 
         // World points use indexed coordinates, including Transform64 translation views.
         const rx = worldPoint[0] - transform.translation_x;
         const ry = worldPoint[1] - transform.translation_y;
         const rz = worldPoint[2] - transform.translation_z;
 
-        rigidBody.accumulatedTorque.set(
-            rigidBody.accumulatedTorque.x + (ry * force.z - rz * force.y),
-            rigidBody.accumulatedTorque.y + (rz * force.x - rx * force.z),
-            rigidBody.accumulatedTorque.z + (rx * force.y - ry * force.x)
+        v3_add(
+            rigidBody.accumulatedTorque, 0,
+            ry * force[2] - rz * force[1],
+            rz * force[0] - rx * force[2],
+            rx * force[1] - ry * force[0]
         );
 
         this.__wake_body(rigidBody);
@@ -1055,13 +1069,18 @@ export class PhysicsSystem extends System {
      * Wakes the body if asleep.
      *
      * @param {RigidBody} rigidBody
-     * @param {Vector3|{x:number,y:number,z:number}} force
+     * @param {Vector3|ArrayLike<number>} force indexed as [x, y, z]
      */
     applyForce(rigidBody, force) {
+        assert.defined(force, 'force');
+        assert.isNumber(force[0], 'force[0]');
+        assert.isNumber(force[1], 'force[1]');
+        assert.isNumber(force[2], 'force[2]');
+
         if (rigidBody.kind !== BodyKind.Dynamic) {
             return;
         }
-        rigidBody.accumulatedForce.add(force);
+        v3_add(rigidBody.accumulatedForce, 0, force[0], force[1], force[2]);
         this.__wake_body(rigidBody);
     }
 
@@ -1069,10 +1088,15 @@ export class PhysicsSystem extends System {
      * Replace the linear velocity. Wakes the body if asleep.
      *
      * @param {RigidBody} rigidBody
-     * @param {Vector3|{x:number,y:number,z:number}} v
+     * @param {Vector3|ArrayLike<number>} v indexed as [x, y, z]
      */
     setLinearVelocity(rigidBody, v) {
-        rigidBody.linearVelocity.copy(v);
+        assert.defined(v, 'v');
+        assert.isNumber(v[0], 'v[0]');
+        assert.isNumber(v[1], 'v[1]');
+        assert.isNumber(v[2], 'v[2]');
+
+        v3_set(rigidBody.linearVelocity, 0, v[0], v[1], v[2]);
         if (rigidBody.kind === BodyKind.Dynamic) {
             this.__wake_body(rigidBody);
         }
@@ -1085,10 +1109,15 @@ export class PhysicsSystem extends System {
      * body, so the spin is silently discarded until something else wakes it.
      *
      * @param {RigidBody} rigidBody
-     * @param {Vector3|{x:number,y:number,z:number}} v
+     * @param {Vector3|ArrayLike<number>} v indexed as [x, y, z]
      */
     setAngularVelocity(rigidBody, v) {
-        rigidBody.angularVelocity.copy(v);
+        assert.defined(v, 'v');
+        assert.isNumber(v[0], 'v[0]');
+        assert.isNumber(v[1], 'v[1]');
+        assert.isNumber(v[2], 'v[2]');
+
+        v3_set(rigidBody.angularVelocity, 0, v[0], v[1], v[2]);
         if (rigidBody.kind === BodyKind.Dynamic) {
             this.__wake_body(rigidBody);
         }
@@ -1096,13 +1125,13 @@ export class PhysicsSystem extends System {
 
     /**
      * Teleport a body to a new pose, bypassing integration: writes the body's
-     * Transform directly and wakes it. For an interpolated body this also flags a
+     * Transform64 directly and wakes it. For an interpolated body this also flags a
      * render `snap` on its {@link Interpolated} component, so the producer keeps
      * this pose (rather than restoring the previous tick over it) and the
      * renderer shows the new pose without sliding across the jump.
      *
      * This is the authoritative way to reposition an interpolated body — a raw
-     * `Transform` write would be undone by the per-step restore. Velocity is left
+     * `Transform64` write would be undone by the per-step restore. Velocity is left
      * as-is; zero it via {@link setLinearVelocity} if the teleport should also
      * stop the body.
      *
@@ -1112,18 +1141,29 @@ export class PhysicsSystem extends System {
      * into must react.
      *
      * @param {RigidBody} rigidBody
-     * @param {Vector3|{x:number,y:number,z:number}} position world position
-     * @param {Quaternion|{x:number,y:number,z:number,w:number}} rotation world unit-quaternion rotation
+     * @param {Vector3|ArrayLike<number>} position world position, indexed as [x, y, z]
+     * @param {Quaternion|ArrayLike<number>} rotation world unit-quaternion rotation, indexed as [x, y, z, w]
      */
     setPose(rigidBody, position, rotation) {
+        assert.defined(position, 'position');
+        assert.isNumber(position[0], 'position[0]');
+        assert.isNumber(position[1], 'position[1]');
+        assert.isNumber(position[2], 'position[2]');
+
+        assert.defined(rotation, 'rotation');
+        assert.isNumber(rotation[0], 'rotation[0]');
+        assert.isNumber(rotation[1], 'rotation[1]');
+        assert.isNumber(rotation[2], 'rotation[2]');
+        assert.isNumber(rotation[3], 'rotation[3]');
+
         const idx = body_id_index(rigidBody._bodyId);
         const transform = this.__transforms[idx];
         if (transform === undefined) {
             return;
         }
 
-        transform.setTranslation(position.x, position.y, position.z);
-        transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+        transform.setTranslation(position[0], position[1], position[2]);
+        transform.setRotation(rotation[0], rotation[1], rotation[2], rotation[3]);
 
         if (rigidBody.kind !== BodyKind.Dynamic) {
             // Static AND Kinematic: the body itself never sleeps and __wake_body is a no-op for it,
@@ -1160,7 +1200,7 @@ export class PhysicsSystem extends System {
         // CLEARS it). The renderer's update runs every render cycle while a fixed step only
         // runs when the accumulator crosses the step size, so a render frame landing between
         // this setPose and the next fixedUpdate clears `snap` before __interp_restore reads
-        // it — restore then overwrites the teleported Transform with the pre-teleport tick's
+        // it — restore then overwrites the teleported Transform64 with the pre-teleport tick's
         // snapshot and the teleport is silently reverted in the SIMULATION. This only bites
         // once InterpolationSystem is wired (the app does not wire it yet). The robust fix is
         // to make the teleport authoritative independent of the shared flag — either overwrite
@@ -1743,8 +1783,6 @@ export class PhysicsSystem extends System {
             // separation path already does via clear_contacts.
             const has_contact = manifolds.is_touched(slot) && manifolds.contact_count(slot) > 0;
 
-            // Scratch payload — write the point/normal components by index to
-            // skip the Vector3 change-signal dispatch (nothing observes them).
             const pt = payload.point;
             const nm = payload.normal;
             if (has_contact) {
@@ -1955,12 +1993,12 @@ export class PhysicsSystem extends System {
      */
     fixedUpdate(dt) {
         // Producer: restore authoritative pose (undo render interpolation)
-        // before the sim reads any Transform this step.
+        // before the sim reads any Transform64 this step.
         this.__interp_restore();
 
-        const gx = this.gravity.x;
-        const gy = this.gravity.y;
-        const gz = this.gravity.z;
+        const gx = this.gravity[0];
+        const gy = this.gravity[1];
+        const gz = this.gravity[2];
 
         const storage = this.storage;
         const bodies = this.__bodies;
@@ -2273,7 +2311,7 @@ export class PhysicsSystem extends System {
         apply_restitution(manifolds, this);
 
         // Scatter the solved persistent linear / angular velocity back onto the
-        // RigidBody components (pose was written through to the Transforms each
+        // RigidBody components (pose was written through to the transforms each
         // substep). After this the bodies are authoritative again for CCD,
         // interpolation recording, and the sleep test below.
         solver_state.scatter(bodies);

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

@@ -9,10 +9,16 @@ export const RIGID_BODY_UNALLOCATED: number;
 /**
  * Rigid-body component.
  *
- * Pose lives on {@link Transform}; this component owns the dynamic state that is not
+ * Pose lives on {@link Transform64}; this component owns the dynamic state that is not
  * part of TRS: velocity, mass, inertia, damping, gravity scale, layer / mask
  * filtering and a small set of bit-flags ({@link RigidBodyFlags}).
  *
+ * The vector fields are raw three-element `Float64Array`s, indexed `[0] [1] [2]` for
+ * x, y, z. They are plain storage: no change signal, no setter dispatch, nothing to
+ * subscribe to. The solver writes them thousands of times per step and every one of
+ * those writes is a typed-array store. Use {@link v3_set} to write all three at once —
+ * `array.set(x, y, z)` is `TypedArray.prototype.set`, which silently writes nothing.
+ *
  * Defaults are conservative: the body translates under forces but cannot rotate
  * unless the user explicitly sets {@link inverseInertiaLocal} — forgetting to
  * configure inertia results in a locked-rotation body, never a NaN tumble.
@@ -28,30 +34,30 @@ export class RigidBody {
     /**
      * Linear velocity in world space, m/s.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly linearVelocity: Vector3;
+    readonly linearVelocity: Float64Array;
     /**
      * Angular velocity in world space, rad/s.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly angularVelocity: Vector3;
+    readonly angularVelocity: Float64Array;
     /**
      * Accumulator for forces applied between fixed-update steps. Consumed and
      * zeroed by the integrator. User code applies via
      * {@link PhysicsSystem#applyForce}; do not write directly.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly accumulatedForce: Vector3;
+    readonly accumulatedForce: Float64Array;
     /**
      * Accumulator for torques applied between fixed-update steps. Consumed and
      * zeroed by the integrator.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly accumulatedTorque: Vector3;
+    readonly accumulatedTorque: Float64Array;
     /**
      * Total mass, kg. Must be positive for Dynamic bodies; Static / Kinematic
      * bodies behave as if mass were infinite regardless of this value.
@@ -63,9 +69,9 @@ export class RigidBody {
      * corresponding rotational degree of freedom. The default of (0,0,0) means
      * rotation is locked until the user sets a value.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly inverseInertiaLocal: Vector3;
+    readonly inverseInertiaLocal: Float64Array;
     /**
      * @type {number}
      */
@@ -221,7 +227,6 @@ export namespace RigidBody {
     let typeName: string;
 }
 import { BodyKind } from "./BodyKind.js";
-import Vector3 from "../../../core/geom/Vector3.js";
 import { RigidBodyFlags } from "./RigidBodyFlags.js";
 import { SleepState } from "./SleepState.js";
 //# sourceMappingURL=RigidBody.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RigidBody.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBody.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH,MAFU,QAAQ,GAAC,MAAM,CAED;IAExB;;;;OAIG;IACH,yBAFU,OAAO,CAEqB;IAEtC;;;;OAIG;IACH,0BAFU,OAAO,CAEsB;IAEvC;;;;;;OAMG;IACH,2BAFU,OAAO,CAEuB;IAExC;;;;;OAKG;IACH,4BAFU,OAAO,CAEwB;IAEzC;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,8BAFU,OAAO,CAE0B;IAE3C;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEM;IAEtB;;OAEG;IACH,OAFU,cAAc,GAAC,MAAM,CAEH;IAE5B;;;;;;;;;;OAUG;IACH,YAFU,UAAU,GAAC,MAAM,CAEG;IAE9B;;;;;;;;;;;OAWG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;;;;;;OAWG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,SAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,cAFW,MAAM,GAAC,cAAc,QAI/B;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,cAAc,QAI/B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBC;IAED,0BAcC;IAED;;;;;;;;;;OAUG;IACH,cAHW,SAAS,GACP,OAAO,CAmBnB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAiBlB;IASL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAZ9B;;kBAIS,MAAM;;yBAxSS,eAAe;oBADpB,+BAA+B;+BAEpB,qBAAqB;2BACzB,iBAAiB"}
+{"version":3,"file":"RigidBody.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBody.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB;AA6BzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAEI;;OAEG;IACH,MAFU,QAAQ,GAAC,MAAM,CAED;IAExB;;;;OAIG;IACH,yBAFU,YAAY,CAEe;IAErC;;;;OAIG;IACH,0BAFU,YAAY,CAEgB;IAEtC;;;;;;OAMG;IACH,2BAFU,YAAY,CAEiB;IAEvC;;;;;OAKG;IACH,4BAFU,YAAY,CAEkB;IAExC;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,8BAFU,YAAY,CAEoB;IAE1C;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEM;IAEtB;;OAEG;IACH,OAFU,cAAc,GAAC,MAAM,CAEH;IAE5B;;;;;;;;;;OAUG;IACH,YAFU,UAAU,GAAC,MAAM,CAEG;IAE9B;;;;;;;;;;;OAWG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;;;;;;OAWG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,SAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,cAFW,MAAM,GAAC,cAAc,QAI/B;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,cAAc,QAI/B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBC;IAED,0BAcC;IAED;;;;;;;;;;OAUG;IACH,cAHW,SAAS,GACP,OAAO,CAmBnB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAiBlB;IASL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAZ9B;;kBAIS,MAAM;;yBAzUS,eAAe;+BACT,qBAAqB;2BACzB,iBAAiB"}

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

@@ -1,5 +1,6 @@
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
-import Vector3 from "../../../core/geom/Vector3.js";
+import { v3_equals_array } from "../../../core/geom/vec3/v3_equals_array.js";
+import { v3_hash } from "../../../core/geom/vec3/v3_hash.js";
 import { BodyKind } from "./BodyKind.js";
 import { RigidBodyFlags } from "./RigidBodyFlags.js";
 import { SleepState } from "./SleepState.js";
@@ -13,13 +14,46 @@ import { SleepState } from "./SleepState.js";
  */
 export const RIGID_BODY_UNALLOCATED = -1;
 
+/**
+ * Read a `{x, y, z}` (or scalar) JSON value into a 3-component span.
+ *
+ * @param {Float64Array} target
+ * @param {{x:number, y:number, z:number}|number} json
+ */
+function v3_from_json(target, json) {
+    if (typeof json === "number") {
+        // scalar shorthand, kept from the Vector3-backed encoding
+        target[0] = json;
+        target[1] = json;
+        target[2] = json;
+    } else {
+        target[0] = json.x;
+        target[1] = json.y;
+        target[2] = json.z;
+    }
+}
+
+/**
+ * @param {Float64Array} v
+ * @returns {{x:number, y:number, z:number}}
+ */
+function v3_to_json(v) {
+    return { x: v[0], y: v[1], z: v[2] };
+}
+
 /**
  * Rigid-body component.
  *
- * Pose lives on {@link Transform}; this component owns the dynamic state that is not
+ * Pose lives on {@link Transform64}; this component owns the dynamic state that is not
  * part of TRS: velocity, mass, inertia, damping, gravity scale, layer / mask
  * filtering and a small set of bit-flags ({@link RigidBodyFlags}).
  *
+ * The vector fields are raw three-element `Float64Array`s, indexed `[0] [1] [2]` for
+ * x, y, z. They are plain storage: no change signal, no setter dispatch, nothing to
+ * subscribe to. The solver writes them thousands of times per step and every one of
+ * those writes is a typed-array store. Use {@link v3_set} to write all three at once —
+ * `array.set(x, y, z)` is `TypedArray.prototype.set`, which silently writes nothing.
+ *
  * Defaults are conservative: the body translates under forces but cannot rotate
  * unless the user explicitly sets {@link inverseInertiaLocal} — forgetting to
  * configure inertia results in a locked-rotation body, never a NaN tumble.
@@ -37,33 +71,33 @@ export class RigidBody {
     /**
      * Linear velocity in world space, m/s.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    linearVelocity = new Vector3(0, 0, 0);
+    linearVelocity = new Float64Array(3);
 
     /**
      * Angular velocity in world space, rad/s.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    angularVelocity = new Vector3(0, 0, 0);
+    angularVelocity = new Float64Array(3);
 
     /**
      * Accumulator for forces applied between fixed-update steps. Consumed and
      * zeroed by the integrator. User code applies via
      * {@link PhysicsSystem#applyForce}; do not write directly.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    accumulatedForce = new Vector3(0, 0, 0);
+    accumulatedForce = new Float64Array(3);
 
     /**
      * Accumulator for torques applied between fixed-update steps. Consumed and
      * zeroed by the integrator.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    accumulatedTorque = new Vector3(0, 0, 0);
+    accumulatedTorque = new Float64Array(3);
 
     /**
      * Total mass, kg. Must be positive for Dynamic bodies; Static / Kinematic
@@ -77,9 +111,9 @@ export class RigidBody {
      * corresponding rotational degree of freedom. The default of (0,0,0) means
      * rotation is locked until the user sets a value.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    inverseInertiaLocal = new Vector3(0, 0, 0);
+    inverseInertiaLocal = new Float64Array(3);
 
     /**
      * @type {number}
@@ -210,10 +244,10 @@ export class RigidBody {
     toJSON() {
         return {
             kind: this.kind,
-            linearVelocity: this.linearVelocity.toJSON(),
-            angularVelocity: this.angularVelocity.toJSON(),
+            linearVelocity: v3_to_json(this.linearVelocity),
+            angularVelocity: v3_to_json(this.angularVelocity),
             mass: this.mass,
-            inverseInertiaLocal: this.inverseInertiaLocal.toJSON(),
+            inverseInertiaLocal: v3_to_json(this.inverseInertiaLocal),
             linearDamping: this.linearDamping,
             angularDamping: this.angularDamping,
             gravityScale: this.gravityScale,
@@ -227,10 +261,10 @@ export class RigidBody {
 
     fromJSON(json) {
         if (json.kind !== undefined) this.kind = json.kind;
-        if (json.linearVelocity !== undefined) this.linearVelocity.fromJSON(json.linearVelocity);
-        if (json.angularVelocity !== undefined) this.angularVelocity.fromJSON(json.angularVelocity);
+        if (json.linearVelocity !== undefined) v3_from_json(this.linearVelocity, json.linearVelocity);
+        if (json.angularVelocity !== undefined) v3_from_json(this.angularVelocity, json.angularVelocity);
         if (json.mass !== undefined) this.mass = json.mass;
-        if (json.inverseInertiaLocal !== undefined) this.inverseInertiaLocal.fromJSON(json.inverseInertiaLocal);
+        if (json.inverseInertiaLocal !== undefined) v3_from_json(this.inverseInertiaLocal, json.inverseInertiaLocal);
         if (json.linearDamping !== undefined) this.linearDamping = json.linearDamping;
         if (json.angularDamping !== undefined) this.angularDamping = json.angularDamping;
         if (json.gravityScale !== undefined) this.gravityScale = json.gravityScale;
@@ -266,9 +300,9 @@ export class RigidBody {
             && this.flags === other.flags
             && this.sleepState === other.sleepState
             && this.sleep_timer === other.sleep_timer
-            && this.linearVelocity.equals(other.linearVelocity)
-            && this.angularVelocity.equals(other.angularVelocity)
-            && this.inverseInertiaLocal.equals(other.inverseInertiaLocal);
+            && v3_equals_array(this.linearVelocity, 0, other.linearVelocity, 0)
+            && v3_equals_array(this.angularVelocity, 0, other.angularVelocity, 0)
+            && v3_equals_array(this.inverseInertiaLocal, 0, other.inverseInertiaLocal, 0);
     }
 
     /**
@@ -287,9 +321,9 @@ export class RigidBody {
         h = (h * 31 + (this.flags | 0)) | 0;
         h = (h * 31 + (this.sleepState | 0)) | 0;
         h = (h * 31 + computeHashFloat(this.sleep_timer)) | 0;
-        h = (h * 31 + this.linearVelocity.hash()) | 0;
-        h = (h * 31 + this.angularVelocity.hash()) | 0;
-        h = (h * 31 + this.inverseInertiaLocal.hash()) | 0;
+        h = (h * 31 + v3_hash(this.linearVelocity, 0)) | 0;
+        h = (h * 31 + v3_hash(this.angularVelocity, 0)) | 0;
+        h = (h * 31 + v3_hash(this.inverseInertiaLocal, 0)) | 0;
         return h;
     }
 }