@woosh/meep-engine 3.20.0 → 3.22.0

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();

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

@@ -1,7 +1,7 @@
 /**
  * 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,
@@ -70,7 +70,7 @@ export class PhysicsSystem extends System<any> {
      * 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.
@@ -127,17 +127,21 @@ export class PhysicsSystem extends System<any> {
      */
     contactDampingRatio: number;
     /**
-     * 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
      */
     private __contact_payload;
     /**
-     * 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}
      */
-    readonly gravity: Vector3;
+    readonly gravity: Float64Array;
     /**
      * Optional global contact filter. Called for each surviving broadphase
      * pair; returning `false` discards the pair.
@@ -159,16 +163,16 @@ export class PhysicsSystem extends System<any> {
     readonly __transforms: Transform64[];
     /**
      * 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: Array<Array<{
         collider: Collider;
-        transform: Transform;
+        transform: Transform64;
         entity: number;
         bvhNode: number;
     }>>;
@@ -315,22 +319,18 @@ export class PhysicsSystem extends System<any> {
     private __reset_pseudo_velocity;
     /**
      * 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: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    setGravity(v: Vector3 | ArrayLike<number>): void;
     /**
      * Install (or remove with `null`) the contact filter callback.
      * @param {((entityA:number, entityB:number, colliderA:Collider, colliderB:Collider) => boolean) | null} fn
      */
-    setContactFilter(fn: (entityA: number, entityB: number, colliderA: Collider, colliderB: Collider) => boolean): void;
+    setContactFilter(fn: ((entityA: number, entityB: number, colliderA: Collider, colliderB: Collider) => boolean) | null): void;
     /**
      * @returns {((entityA:number, entityB:number, colliderA:Collider, colliderB:Collider) => boolean) | null}
      */
-    getContactFilter(): (entityA: number, entityB: number, colliderA: Collider, colliderB: Collider) => boolean;
+    getContactFilter(): ((entityA: number, entityB: number, colliderA: Collider, colliderB: Collider) => boolean) | null;
     /**
      * @private
      * @param {RigidBody} rb
@@ -387,8 +387,8 @@ export class PhysicsSystem extends System<any> {
      * 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.
      *
@@ -451,13 +451,9 @@ export class PhysicsSystem extends System<any> {
      * 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: RigidBody, impulse: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    applyImpulse(rigidBody: RigidBody, impulse: Vector3 | ArrayLike<number>): void;
     /**
      * Apply an instantaneous change of momentum at a specific world-space point.
      * Off-centre impulses produce both linear (Δv = P/m) and angular
@@ -466,15 +462,11 @@ export class PhysicsSystem extends System<any> {
      * 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(rigidBody: RigidBody, transform: Transform64, impulse: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }, worldPoint: Vector3 | ArrayLike<number>): void;
+    applyImpulseAt(rigidBody: RigidBody, transform: Transform64, impulse: Vector3 | ArrayLike<number>, worldPoint: Vector3 | ArrayLike<number>): void;
     /**
      * Accumulate a continuous torque (world-space) for integration on the
      * next fixedUpdate. Pairs with {@link applyForce} for the rotational case.
@@ -482,13 +474,9 @@ export class PhysicsSystem extends System<any> {
      * 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: RigidBody, torque: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    applyTorque(rigidBody: RigidBody, torque: Vector3 | ArrayLike<number>): void;
     /**
      * Apply a continuous force at a specific world-space point. The force
      * generates both a linear acceleration (F/m) and a torque (r × F) about
@@ -497,38 +485,26 @@ export class PhysicsSystem extends System<any> {
      * 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: RigidBody, transform: Transform64, force: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }, worldPoint: Vector3 | ArrayLike<number>): void;
+    applyForceAt(rigidBody: RigidBody, transform: Transform64, force: Vector3 | ArrayLike<number>, worldPoint: Vector3 | ArrayLike<number>): void;
     /**
      * Accumulate a continuous force to be integrated next fixedUpdate step.
      * 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: RigidBody, force: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    applyForce(rigidBody: RigidBody, force: Vector3 | ArrayLike<number>): void;
     /**
      * 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: RigidBody, v: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    setLinearVelocity(rigidBody: RigidBody, v: Vector3 | ArrayLike<number>): void;
     /**
      * Replace the angular velocity. Wakes the body if asleep.
      *
@@ -536,22 +512,18 @@ export class PhysicsSystem extends System<any> {
      * 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: RigidBody, v: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    setAngularVelocity(rigidBody: RigidBody, v: Vector3 | ArrayLike<number>): void;
     /**
      * 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.
      *
@@ -561,19 +533,10 @@ export class PhysicsSystem extends System<any> {
      * 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
-     */
-    setPose(rigidBody: RigidBody, position: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }, rotation: Quaternion | {
-        x: number;
-        y: number;
-        z: number;
-        w: number;
-    }): void;
+     * @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: RigidBody, position: Vector3 | ArrayLike<number>, rotation: Quaternion | ArrayLike<number>): void;
     /**
      * Force the body awake. Static bodies are ignored.
      * @param {RigidBody} rigidBody
@@ -643,17 +606,15 @@ export class PhysicsSystem extends System<any> {
      *
      * @param {Ray3} ray  origin + unit direction + `tMax`
      * @param {AbstractShape3D} shape
-     * @param {{x:number,y:number,z:number,w:number}} rotation
+     * @param {ArrayLike<number>} rotation fixed orientation of the swept shape
+     *   as `[x, y, z, w]`, a unit quaternion — which a Transform64's `rotation`
+     *   already is. Read by index, so an `{x, y, z, w}` object silently misses
+     *   everything rather than throwing
      * @param {PhysicsSurfacePoint} result populated on hit; untouched on miss
      * @param {(entity:number, collider:Collider)=>boolean} [filter]
      * @returns {boolean}
      */
-    shapeCast(ray: Ray3, shape: AbstractShape3D, rotation: {
-        x: number;
-        y: number;
-        z: number;
-        w: number;
-    }, result: PhysicsSurfacePoint, filter?: (entity: number, collider: Collider) => boolean): boolean;
+    shapeCast(ray: Ray3, shape: AbstractShape3D, rotation: ArrayLike<number>, result: PhysicsSurfacePoint, filter?: (entity: number, collider: Collider) => boolean): boolean;
     /**
      * Find every body whose collider overlaps the given convex shape at the
      * given world pose, without mutating the simulation. Intended for

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

@@ -1 +1 @@
-{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}