@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/animation/curve/binding/BoundTransform64Writer.js

@@ -0,0 +1,80 @@
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import { BoundValueWriter } from "./BoundValueWriter.js";
+
+/**
+ * @enum {string}
+ */
+export const Transform64Channel = {
+    Translation: "translation",
+    Rotation: "rotation",
+    Scale: "scale"
+};
+
+/**
+ * @type {Quaternion}
+ */
+const SCRATCH_ROTATION = new Quaternion();
+
+/**
+ * Animate one component of an {@link EntityNode}'s pose.
+ *
+ * A {@link Transform64} keeps its three components as spans of one array, so there is no
+ * {@link Vector3} or {@link Quaternion} on it for {@link BoundVector3Writer} to hold on to - which
+ * is why the pose gets a writer of its own rather than reusing those.
+ *
+ * The writer owns three obligations a curve should not have to know about: only a translation write
+ * lands in the matrix by itself, so a rotation or a scale write recomposes; and the node's pose is
+ * not the entity's, so the write is followed by the sync that pushes it into the components the
+ * rest of the engine reads.
+ */
+export class BoundTransform64Writer extends BoundValueWriter {
+    /**
+     * @type {EntityNode|null}
+     */
+    #node = null;
+
+    /**
+     * @type {string}
+     */
+    #channel = Transform64Channel.Translation;
+
+    /**
+     * @param {EntityNode} node
+     * @param {string} channel one of {@link Transform64Channel}
+     */
+    constructor(node, channel) {
+        super();
+
+        this.#node = node;
+        this.#channel = channel;
+    }
+
+    write(data) {
+        const transform = this.#node.transform;
+
+        switch (this.#channel) {
+            case Transform64Channel.Translation:
+                // the translation IS the matrix's fourth column, so this is already whole
+                transform.setTranslation(data[0], data[1], data[2]);
+                break;
+
+            case Transform64Channel.Rotation:
+                // curve output is interpolated, so it is very slightly off unit length
+                SCRATCH_ROTATION.set(data[0], data[1], data[2], data[3]).normalize();
+
+                transform.setRotation(
+                    SCRATCH_ROTATION.x, SCRATCH_ROTATION.y,
+                    SCRATCH_ROTATION.z, SCRATCH_ROTATION.w
+                );
+                transform.updateMatrix();
+                break;
+
+            case Transform64Channel.Scale:
+                transform.setScale(data[0], data[1], data[2]);
+                transform.updateMatrix();
+                break;
+        }
+
+        this.#node.transform_changed();
+    }
+}

package/src/engine/animation/removeEntityWithMeshParticlesEffect.js

@@ -3,7 +3,7 @@ import { SerializationMetadata } from "../ecs/components/SerializationMetadata.j
 import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
 import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
 import Trail2D from "../graphics/ecs/trail2d/Trail2D.js";
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import Entity from "../ecs/Entity.js";
 import { stopEntityAndNotifyWhenStopped } from "./AnimatedActions.js";
 
@@ -157,7 +157,7 @@ export function removeEntityWithMeshParticlesEffect(
     const emitter = ParticleEmitter.fromJSON(lib[particles]);
 
     //prevent further interactions
-    removeComponentsExcept(ecd, entity, [SGMesh, ParticleEmitter, Trail2D, Transform]);
+    removeComponentsExcept(ecd, entity, [SGMesh, ParticleEmitter, Trail2D, Transform64]);
 
     //make entity volatile so it does not end up in game saves. The entity is mid-death here;
     //without this a save taken during the effect would restore a corpse that never finishes dying.
@@ -165,9 +165,9 @@ export function removeEntityWithMeshParticlesEffect(
 
     /**
      *
-     * @type {Transform}
+     * @type {Transform64}
      */
-    const originalTransform = ecd.getComponent(entity, Transform);
+    const originalTransform = ecd.getComponent(entity, Transform64);
 
     if (originalTransform === undefined) {
         throw new Error(`entity ${entity} doesn't have Transform`);

package/src/engine/asset/loaders/gltf_test_fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/gltf_test_fixtures.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH,sCAFa,WAAW,CAWvB;AAED;;;GAGG;AACH,qDAHW,MAAM,GAAC,SAAS,GACd,MAAM,CA+BlB;AAED;;;;;;;;;;GAUG;AACH,8DAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;GAIG;AACH,sCAFa,WAAW,CAiCvB;AAsCD;;;;;;;;;;;;;;;;;GAiBG;AACH;IAJ4B,aAAa,GAA9B,MAAM;IACY,MAAM,GAAxB,OAAO;;YACI,WAAW;;oBAAsB,MAAM;oBAAa,MAAM;;EA2C/E;AAED;;;;;;;GAOG;AACH,iEAPW,MAAM,cACN,MAAM,GAAC,SAAS;IAEC,aAAa,GAA9B,MAAM;IACY,MAAM,GAAxB,OAAO;IACL,MAAM,CA8ElB;AAED;;;;;;GAMG;AACH,2DAJW,MAAM,kBAEJ,WAAW,CAkCvB;AA3VD,iDAAkD;AAClD,iDAAkD;AAElD;;;;GAIG;AACH,2CAFU,MAAM,CAEgC;AA2HhD;;;;;GAKG;AACH,gDAFU,MAAM,CAE8D;AAa9E;;;;GAIG;AACH,mCAFU,MAAM,EAAE,CAMhB"}
+{"version":3,"file":"gltf_test_fixtures.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/gltf_test_fixtures.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,sCAFa,WAAW,CAWvB;AAED;;;GAGG;AACH,qDAHW,MAAM,GAAC,SAAS,GACd,MAAM,CA+BlB;AAED;;;;;;;;;;GAUG;AACH,8DAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;GAIG;AACH,sCAFa,WAAW,CAiCvB;AAsCD;;;;;;;;;;;;;;;;;GAiBG;AACH;IAJ4B,aAAa,GAA9B,MAAM;IACY,MAAM,GAAxB,OAAO;;YACI,WAAW;;oBAAsB,MAAM;oBAAa,MAAM;;EA2C/E;AAED;;;;;;;GAOG;AACH,iEAPW,MAAM,cACN,MAAM,GAAC,SAAS;IAEC,aAAa,GAA9B,MAAM;IACY,MAAM,GAAxB,OAAO;IACL,MAAM,CA8ElB;AAED;;;;;;GAMG;AACH,2DAJW,MAAM,kBAEJ,WAAW,CAkCvB;AA3VD,iDAAkD;AAClD,iDAAkD;AAElD;;;;GAIG;AACH,2CAFU,MAAM,CAEgC;AA2HhD;;;;;GAKG;AACH,gDAFU,MAAM,CAE8D;AAa9E;;;;GAIG;AACH,mCAFU,MAAM,EAAE,CAMhB"}

package/src/engine/asset/loaders/gltf_test_fixtures.js

@@ -7,6 +7,7 @@
  */
 
 import { encode_meshopt_attributes } from "../../../core/binary/meshopt/__meshopt_test_streams.js";
+import { align_4 } from "../../../core/binary/align_4.js";
 
 export const GLTF_FIXTURE_NODE_NAME = 'unit_root';
 export const GLTF_FIXTURE_MESH_NAME = 'unit_body';
@@ -104,10 +105,10 @@ export function build_triangle_glb() {
     const json_bytes = new TextEncoder().encode(JSON.stringify(build_triangle_gltf_json(undefined)));
 
     // both chunks are padded to a four byte boundary, per the container's own rule
-    const json_length = Math.ceil(json_bytes.byteLength / 4) * 4;
+    const json_length = align_4(json_bytes.byteLength);
 
     const bin = new Uint8Array(build_triangle_bin());
-    const bin_length = Math.ceil(bin.byteLength / 4) * 4;
+    const bin_length = align_4(bin.byteLength);
 
     const total = 12 + 8 + json_length + 8 + bin_length;
 
@@ -328,10 +329,10 @@ export function build_meshopt_triangle_glb(extension_name, options = {}) {
         JSON.stringify(build_meshopt_triangle_gltf_json(extension_name, undefined, options))
     );
 
-    const json_length = Math.ceil(json_bytes.byteLength / 4) * 4;
+    const json_length = align_4(json_bytes.byteLength);
 
     const bin = new Uint8Array(build_meshopt_triangle_bin(options).buffer);
-    const bin_length = Math.ceil(bin.byteLength / 4) * 4;
+    const bin_length = align_4(bin.byteLength);
 
     const total = 12 + 8 + json_length + 8 + bin_length;
 

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts

@@ -18,8 +18,8 @@
  */
 export class FirstPersonPlayerControllerSystem extends System<any> {
     constructor();
-    dependencies: (typeof Transform | typeof FirstPersonPlayerController)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Camera>)[];
+    dependencies: (typeof Transform64 | typeof FirstPersonPlayerController)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Camera>)[];
     /**
      * Per-entity runtime, keyed by entity id.
      * @type {Map<number, PerEntityRuntime>}
@@ -83,16 +83,16 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
     startup(entityManager: any): Promise<void>;
     /**
      * @param {FirstPersonPlayerController} controller
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} entity
      */
-    link(controller: FirstPersonPlayerController, bodyTransform: Transform, entity: number): void;
+    link(controller: FirstPersonPlayerController, bodyTransform: Transform64, entity: number): void;
     /**
      * @param {FirstPersonPlayerController} controller
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} entity
      */
-    unlink(controller: FirstPersonPlayerController, bodyTransform: Transform, entity: number): void;
+    unlink(controller: FirstPersonPlayerController, bodyTransform: Transform64, entity: number): void;
     /**
      * Look up the per-entity runtime for an entity that has this
      * controller. Used by cross-system code (sensors system, future
@@ -163,7 +163,7 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} dt
      */
     private _advanceJumpFsm;
@@ -178,7 +178,7 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} dt
      */
     private _integrateVerticalAndResolveGround;
@@ -247,7 +247,7 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} dt
      * @param {boolean} isCrouchActive
      * @param {boolean} isSprintIntent
@@ -280,7 +280,7 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      */
     private _publishPose;
     /**
@@ -330,7 +330,7 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
     private _composeEye;
 }
 import { System } from "../../ecs/System.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 import { FirstPersonPlayerController } from "./FirstPersonPlayerController.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { RigidBody } from "../../physics/ecs/RigidBody.js";
@@ -344,7 +344,7 @@ import { Camera } from "../../graphics/ecs/camera/Camera.js";
 declare class PerEntityRuntime {
     /**
      * Co-attached kinematic body. Set by {@link FirstPersonPlayerControllerSystem.link}
-     * after asserting it's present. The controller writes Transform.position
+     * after asserting it's present. The controller writes Transform64.position
      * directly (existing motion logic); physics derives the body's velocity
      * from the per-step delta. Other physics systems (raycasts, contact
      * events) see the player through this body.

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts.map

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

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.js

@@ -12,7 +12,7 @@ import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessS
 import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
 import Entity from "../../ecs/Entity.js";
 import { System } from "../../ecs/System.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 import { Camera } from "../../graphics/ecs/camera/Camera.js";
 import { BodyKind } from "../../physics/ecs/BodyKind.js";
 import { Collider } from "../../physics/ecs/Collider.js";
@@ -32,6 +32,7 @@ import { stepTowards } from "./math/stepTowards.js";
 import { FirstPersonActionState, FirstPersonLocomotionMode } from "./pose/FirstPersonPose.js";
 import { FirstPersonPosture } from "./pose/FirstPersonPosture.js";
 import { FirstPersonSensors } from "./sensors/FirstPersonSensors.js";
+import { t64_announce_change } from "../../ecs/transform/t64_announce_change.js";
 
 // ---------------------------------------------------------------------------
 // Scratch allocations — reused per frame to avoid GC pressure
@@ -42,6 +43,8 @@ const SCRATCH_V3_C = new Vector3();
 const SCRATCH_Q_A = new Quaternion();
 const SCRATCH_Q_B = new Quaternion();
 const SCRATCH_Q_C = new Quaternion();
+/** the transform holds its rotation as four numbers, so euler and axis-angle work goes through here */
+const SCRATCH_Q_EULER = new Quaternion();
 
 const TWO_PI = Math.PI * 2;
 const LN2 = Math.log(2);
@@ -100,7 +103,7 @@ function makePostureCapsule(radius, totalHeight) {
 class PerEntityRuntime {
     /**
      * Co-attached kinematic body. Set by {@link FirstPersonPlayerControllerSystem.link}
-     * after asserting it's present. The controller writes Transform.position
+     * after asserting it's present. The controller writes Transform64.position
      * directly (existing motion logic); physics derives the body's velocity
      * from the per-step delta. Other physics systems (raycasts, contact
      * events) see the player through this body.
@@ -397,10 +400,10 @@ export class FirstPersonPlayerControllerSystem extends System {
     // never link — the controller would appear inert with no
     // diagnostic. The assert below catches the missing-body case
     // explicitly.
-    dependencies = [FirstPersonPlayerController, Transform];
+    dependencies = [FirstPersonPlayerController, Transform64];
 
     components_used = [
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Write),
         ResourceAccessSpecification.from(Camera, ResourceAccessKind.Write),
         ResourceAccessSpecification.from(RigidBody, ResourceAccessKind.Write),
     ];
@@ -484,7 +487,7 @@ export class FirstPersonPlayerControllerSystem extends System {
 
     /**
      * @param {FirstPersonPlayerController} controller
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} entity
      */
     link(controller, bodyTransform, entity) {
@@ -578,14 +581,20 @@ export class FirstPersonPlayerControllerSystem extends System {
 
         // Seed yaw from the starting body rotation. `toEulerAnglesYXZ`
         // returns (pitch, yaw, roll) — we only care about y.
-        bodyTransform.rotation.toEulerAnglesYXZ(SCRATCH_V3_A);
+        SCRATCH_Q_EULER.set(
+            bodyTransform.rotation_x,
+            bodyTransform.rotation_y,
+            bodyTransform.rotation_z,
+            bodyTransform.rotation_w
+        );
+        SCRATCH_Q_EULER.toEulerAnglesYXZ(SCRATCH_V3_A);
         runtime.bodyYaw = SCRATCH_V3_A.y;
         runtime.eyePitch = 0;
 
         // Seed render-rate-look + position-interpolation state to the spawn pose.
         runtime.prevFixedYaw = runtime.bodyYaw;
-        runtime.renderPrevPos.copy(bodyTransform.position);
-        runtime.renderCurPos.copy(bodyTransform.position);
+        runtime.renderPrevPos.set(bodyTransform.translation_x, bodyTransform.translation_y, bodyTransform.translation_z);
+        runtime.renderCurPos.set(bodyTransform.translation_x, bodyTransform.translation_y, bodyTransform.translation_z);
 
         // Initialize springs to standing-eye-height baseline
         runtime.eyeHeightSpring.settle(controller.config.body.height);
@@ -596,10 +605,10 @@ export class FirstPersonPlayerControllerSystem extends System {
         if (controller.eyeEntity === -1 || !ecd.entityExists(controller.eyeEntity)) {
             const eye = new Entity();
 
-            const eyeTransform = new Transform();
-            const baseEyePos = SCRATCH_V3_A.copy(bodyTransform.position);
+            const eyeTransform = new Transform64();
+            const baseEyePos = SCRATCH_V3_A.set(bodyTransform.translation_x, bodyTransform.translation_y, bodyTransform.translation_z);
             baseEyePos.y += controller.config.body.height;
-            eyeTransform.position.copy(baseEyePos);
+            eyeTransform.setTranslation(baseEyePos.x, baseEyePos.y, baseEyePos.z);
 
             const camera = new Camera();
             camera.active.set(true);
@@ -622,7 +631,7 @@ export class FirstPersonPlayerControllerSystem extends System {
 
     /**
      * @param {FirstPersonPlayerController} controller
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} entity
      */
     unlink(controller, bodyTransform, entity) {
@@ -689,7 +698,7 @@ export class FirstPersonPlayerControllerSystem extends System {
         const state = controller.state;
         const sig = controller.signals;
 
-        const bodyTransform = ecd.getComponent(entity, Transform);
+        const bodyTransform = ecd.getComponent(entity, Transform64);
         if (bodyTransform === undefined) return;
 
         // Decay the mastery score's EMA. Doing this once per tick keeps the
@@ -716,7 +725,11 @@ export class FirstPersonPlayerControllerSystem extends System {
         // Write body yaw back to the transform (pure yaw, no pitch on body) —
         // the collision sweep + sensors use it. The camera uses runtime.bodyYaw
         // directly, which _consumeLook keeps current at render rate.
-        bodyTransform.rotation.fromAxisAngle(Vector3.up, runtime.bodyYaw);
+        SCRATCH_Q_EULER.fromAxisAngle(Vector3.up, runtime.bodyYaw);
+        bodyTransform.setRotation(
+            SCRATCH_Q_EULER.x, SCRATCH_Q_EULER.y, SCRATCH_Q_EULER.z, SCRATCH_Q_EULER.w
+        );
+        bodyTransform.updateMatrix();
 
         // -- Shared flags. Computed BEFORE the ability tick so abilities
         //    can read them. `isCrouchActive` is deliberately computed
@@ -996,6 +1009,13 @@ export class FirstPersonPlayerControllerSystem extends System {
         // -- L2.h: Publish pose channels --------------------------------
         this._publishPose(controller, runtime, bodyTransform);
 
+        // -- L2.h.1: Say that the body moved ----------------------------
+        // The yaw write above and the mover's write into the translation both land straight on the
+        // component, and a Transform64 announces nothing on its own. One event here, at the point
+        // where the pose is final, covers every writer in the tick and covers them once - which is
+        // what wakes the mesh placement, the audio emitter and anything else that follows a player.
+        t64_announce_change(ecd, entity, bodyTransform);
+
         // -- L2.i: Sync collider shape to posture -----------------------
         // All posture-writers (base locomotion + any active ability)
         // have run for this tick. Swap the collider's shape to the
@@ -1110,7 +1130,7 @@ export class FirstPersonPlayerControllerSystem extends System {
         const ownCollider = runtime.collider;
         const filter = (_e, c) => c !== ownCollider;
         const ray = this._postureRay;
-        ray.setOrigin(bodyTransform.position.x, bodyTransform.position.y, bodyTransform.position.z);
+        ray.setOrigin(bodyTransform.translation_x, bodyTransform.translation_y, bodyTransform.translation_z);
         ray.setDirection(0, 1, 0);
         ray.tMax = growDelta;
         return !this.physicsSystem.shapeCast(ray, fromShape, bodyTransform.rotation, this._postureHit, filter);
@@ -1125,7 +1145,7 @@ export class FirstPersonPlayerControllerSystem extends System {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} dt
      */
     _advanceJumpFsm(controller, runtime, bodyTransform, dt) {
@@ -1189,7 +1209,7 @@ export class FirstPersonPlayerControllerSystem extends System {
                 runtime.velocityY = runtime.jumpInitialVy * masteryMul;
                 runtime.midJump = true;
                 runtime.apexFired = false;
-                runtime.peakAltitude = bodyTransform.position.y;
+                runtime.peakAltitude = bodyTransform.translation_y;
                 state.inJumpAnticipation = false;
                 state.isVariableJumpCut = false;
                 state.isAscending = true;
@@ -1220,7 +1240,7 @@ export class FirstPersonPlayerControllerSystem extends System {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} dt
      */
     _integrateVerticalAndResolveGround(controller, runtime, bodyTransform, dt) {
@@ -1292,7 +1312,7 @@ export class FirstPersonPlayerControllerSystem extends System {
         const filter = (_e, c) => c !== ownCollider;
 
         const result = this._mover.move(
-            bodyTransform.position,
+            bodyTransform.translation,
             bodyTransform.rotation,
             runtime.collider.shape,
             v, dt, filter,
@@ -1336,8 +1356,11 @@ export class FirstPersonPlayerControllerSystem extends System {
     _moveFlatGround(controller, runtime, bodyTransform, dt) {
         const state = controller.state;
 
-        bodyTransform.position._add(
-            runtime.velocityX * dt, runtime.velocityY * dt, runtime.velocityZ * dt,
+        // translation lands in the matrix as it is written, so no updateMatrix is owed here
+        bodyTransform.setTranslation(
+            bodyTransform.translation_x + runtime.velocityX * dt,
+            bodyTransform.translation_y + runtime.velocityY * dt,
+            bodyTransform.translation_z + runtime.velocityZ * dt
         );
 
         if (this.useBuiltInFlatGround || this.groundResolver !== null) {
@@ -1345,13 +1368,13 @@ export class FirstPersonPlayerControllerSystem extends System {
             let testY = this.useBuiltInFlatGround ? this.groundY : Number.NEGATIVE_INFINITY;
             if (this.groundResolver !== null) {
                 const resolved = this.groundResolver(
-                    bodyTransform.position.x, bodyTransform.position.y, bodyTransform.position.z,
+                    bodyTransform.translation_x, bodyTransform.translation_y, bodyTransform.translation_z,
                 );
                 if (resolved !== null && resolved > testY) testY = resolved;
             }
             const haveGround = testY !== Number.NEGATIVE_INFINITY;
-            if (haveGround && bodyTransform.position.y <= testY) {
-                bodyTransform.position.setY(testY);
+            if (haveGround && bodyTransform.translation_y <= testY) {
+                bodyTransform.setTranslation(bodyTransform.translation_x, testY, bodyTransform.translation_z);
                 if (!state.grounded) this._onLand(controller, runtime, -runtime.velocityY);
                 state.grounded = true;
                 state.groundNormal.set(0, 1, 0);
@@ -1418,7 +1441,7 @@ export class FirstPersonPlayerControllerSystem extends System {
     _onLeaveGround(controller, runtime, bodyTransform) {
         controller.signals.onLeaveGround.send1({ reason: runtime.midJump ? "jump" : "fall" });
         runtime.takeoffVy = runtime.velocityY;
-        runtime.peakAltitude = bodyTransform.position.y;
+        runtime.peakAltitude = bodyTransform.translation_y;
     }
 
     /**
@@ -1427,8 +1450,8 @@ export class FirstPersonPlayerControllerSystem extends System {
      */
     _detectJumpApex(controller, runtime, bodyTransform) {
         if (runtime.midJump && !runtime.apexFired) {
-            if (bodyTransform.position.y > runtime.peakAltitude) {
-                runtime.peakAltitude = bodyTransform.position.y;
+            if (bodyTransform.translation_y > runtime.peakAltitude) {
+                runtime.peakAltitude = bodyTransform.translation_y;
             } else if (runtime.velocityY <= 0) {
                 controller.signals.onJumpApex.send0();
                 runtime.apexFired = true;
@@ -1445,7 +1468,7 @@ export class FirstPersonPlayerControllerSystem extends System {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      * @param {number} dt
      * @param {boolean} isCrouchActive
      * @param {boolean} isSprintIntent
@@ -1674,14 +1697,14 @@ export class FirstPersonPlayerControllerSystem extends System {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform} bodyTransform
+     * @param {Transform64} bodyTransform
      */
     _publishPose(controller, runtime, bodyTransform) {
         const cfg = controller.config;
         const state = controller.state;
         const pose = controller.pose;
 
-        pose.rootPosition.copy(bodyTransform.position);
+        pose.rootPosition.set(bodyTransform.translation_x, bodyTransform.translation_y, bodyTransform.translation_z);
         pose.rootYawRad = runtime.bodyYaw;
         pose.headYawRad = runtime.bodyYaw;
         pose.headPitchRad = runtime.eyePitch;
@@ -1737,15 +1760,15 @@ export class FirstPersonPlayerControllerSystem extends System {
      * @private
      */
     _snapshotRenderPose(runtime, bodyTransform) {
-        const p = bodyTransform.position;
+        const p = bodyTransform;
         if (runtime.renderSnap) {
             runtime.renderSnap = false;
-            runtime.renderPrevPos.set(p.x, p.y, p.z);
-            runtime.renderCurPos.set(p.x, p.y, p.z);
+            runtime.renderPrevPos.set(p.translation_x, p.translation_y, p.translation_z);
+            runtime.renderCurPos.set(p.translation_x, p.translation_y, p.translation_z);
             return;
         }
         runtime.renderPrevPos.copy(runtime.renderCurPos);
-        runtime.renderCurPos.set(p.x, p.y, p.z);
+        runtime.renderCurPos.set(p.translation_x, p.translation_y, p.translation_z);
     }
 
     /**
@@ -1759,7 +1782,7 @@ export class FirstPersonPlayerControllerSystem extends System {
      * @private
      */
     _assertTickInvariants(controller, runtime, bodyTransform) {
-        const p = bodyTransform.position;
+        const p = bodyTransform;
         assert.ok(Number.isFinite(runtime.bodyYaw),
             "FP invariant: runtime.bodyYaw is non-finite (camera yaw corrupted)");
         assert.ok(Number.isFinite(runtime.eyePitch),
@@ -1773,7 +1796,7 @@ export class FirstPersonPlayerControllerSystem extends System {
             "FP invariant: runtime.velocity is non-finite",
         );
         assert.ok(
-            Number.isFinite(p.x) && Number.isFinite(p.y) && Number.isFinite(p.z),
+            Number.isFinite(p.translation_x) && Number.isFinite(p.translation_y) && Number.isFinite(p.translation_z),
             "FP invariant: body position is non-finite",
         );
     }
@@ -1841,11 +1864,11 @@ export class FirstPersonPlayerControllerSystem extends System {
         const cfg = controller.config;
         const state = controller.state;
 
-        const bodyTransform = ecd.getComponent(entity, Transform);
+        const bodyTransform = ecd.getComponent(entity, Transform64);
         if (bodyTransform === undefined) return;
 
         if (controller.eyeEntity === -1) return;
-        const eyeTransform = ecd.getComponent(controller.eyeEntity, Transform);
+        const eyeTransform = ecd.getComponent(controller.eyeEntity, Transform64);
         const camera = ecd.getComponent(controller.eyeEntity, Camera);
         if (eyeTransform === undefined || camera === undefined) return;
 
@@ -1928,8 +1951,11 @@ export class FirstPersonPlayerControllerSystem extends System {
         const worldOffset = SCRATCH_V3_B.copy(stack.offset);
         worldOffset.applyQuaternion(qYaw0);
 
-        eyeTransform.position.set(iPosX, iPosY, iPosZ);
-        eyeTransform.position._add(worldOffset.x, worldOffset.y, worldOffset.z);
+        eyeTransform.setTranslation(
+            iPosX + worldOffset.x,
+            iPosY + worldOffset.y,
+            iPosZ + worldOffset.z
+        );
 
         // -- Eye rotation: body yaw × eye pitch × roll -------------------
         // Bob roll mixes in for a subtle head sway (in phase with lateral bob).
@@ -1981,16 +2007,23 @@ export class FirstPersonPlayerControllerSystem extends System {
         const qPitch = SCRATCH_Q_B.fromAxisAngle(Vector3.right, pitchTotal);
         const qRoll = SCRATCH_Q_C.fromAxisAngle(Vector3.forward, rollTotal);
 
-        eyeTransform.rotation.multiplyQuaternions(qYaw, qPitch);
-        eyeTransform.rotation.multiply(qRoll);
+        // composed in a scratch: a transform keeps its rotation as four numbers and has no
+        // quaternion product of its own
+        SCRATCH_Q_EULER.multiplyQuaternions(qYaw, qPitch);
+        SCRATCH_Q_EULER.multiply(qRoll);
+
+        eyeTransform.setRotation(
+            SCRATCH_Q_EULER.x, SCRATCH_Q_EULER.y, SCRATCH_Q_EULER.z, SCRATCH_Q_EULER.w
+        );
+
+        eyeTransform.updateMatrix();
 
         // Dev-only camera-output guard (compiled out of prod). The composed eye
         // direction is exactly what the player sees; if a spring (head-droop,
         // breath nod) or lean ever drove pitch/roll to NaN, the camera would
         // snap to garbage. Assert it here, at the source of the visible jump.
-        const er = eyeTransform.rotation;
         assert.ok(
-            Number.isFinite(er.x) && Number.isFinite(er.y) && Number.isFinite(er.z) && Number.isFinite(er.w),
+            Number.isFinite(eyeTransform.rotation_x) && Number.isFinite(eyeTransform.rotation_y) && Number.isFinite(eyeTransform.rotation_z) && Number.isFinite(eyeTransform.rotation_w),
             "FP invariant: composed eye rotation is non-finite (camera direction corrupted)",
         );
 

package/src/engine/control/first-person/abilities/LedgeGrab.js

@@ -267,7 +267,7 @@ export class LedgeGrab extends Ability {
         //    when the ledge was reached obliquely (a facing-relative offset
         //    would sink it into a thin wall).
         const standoff = controller.config.body.radius + cfg.hangOffsetForward;
-        bodyTransform.position.set(
+        bodyTransform.setTranslation(
             this._anchorX + this._nx * standoff,
             this._edgeY + cfg.hangOffsetY,
             this._anchorZ + this._nz * standoff,

package/src/engine/control/first-person/abilities/Mantle.js

@@ -201,7 +201,7 @@ export class Mantle extends Ability {
         } else {
             y = this._startY + (this._endY - this._startY) * easeOutCubic(t);
         }
-        bodyTransform.position.set(x, y, z);
+        bodyTransform.setTranslation(x, y, z);
         // On the path — no integration; velocity stays 0 until release.
         runtime.velocityX = 0;
         runtime.velocityY = 0;

package/src/engine/control/first-person/abilities/Slide.js

@@ -126,7 +126,7 @@ export class Slide extends Ability {
             runtime.velocityY = runtime.jumpInitialVy * cfg.slideJumpUpFactor;
             runtime.midJump = true;
             runtime.apexFired = false;
-            runtime.peakAltitude = bodyTransform.position.y;
+            runtime.peakAltitude = bodyTransform.translation_y;
             controller.state.isVariableJumpCut = false;
             controller.state.isAscending = true;
             // Mastery: scale the impulse via JumpImpulse evaluators if any.