@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/control/first-person/collision/KinematicMover.d.ts

@@ -36,7 +36,7 @@ export class KinematicMover {
      * @param {import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem} physicsSystem
      * @param {import("../../../ecs/EntityComponentDataset.js").EntityComponentDataset} ecd
      *   used to resolve an overlapping `body_id` (via
-     *   `physicsSystem.entityOf`) back to its {@link Transform} +
+     *   `physicsSystem.entityOf`) back to its {@link Transform64} +
      *   {@link Collider} for `compute_penetration`.
      * @param {object} [options]
      * @param {number} [options.skin=0.005] clearance left after each
@@ -130,7 +130,8 @@ export class KinematicMover {
      * `velocity` to the corrected value.
      *
      * @param {Vector3} position in/out — current pose, written to the resolved pose
-     * @param {{x:number,y:number,z:number,w:number}} rotation capsule orientation (read)
+     * @param {ArrayLike<number>} rotation capsule orientation as `[x, y, z, w]` (read) - a
+     *   Quaternion is one, and so is a Transform64's rotation
      * @param {import("../../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D} shape convex capsule
      * @param {Vector3} velocity in/out — desired velocity, written to the corrected velocity
      * @param {number} dt
@@ -138,12 +139,7 @@ export class KinematicMover {
      *   the player's own body in integration; accept-all in isolation
      * @returns {{hit:boolean, grounded:boolean, groundNormal:Vector3, groundBody:number, groundEntity:number, stepUp:number, landed:boolean, landingSpeed:number}} reused result — see {@link _result} for what each field is for
      */
-    move(position: Vector3, rotation: {
-        x: number;
-        y: number;
-        z: number;
-        w: number;
-    }, shape: import("../../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D, velocity: Vector3, dt: number, filter: (entity: number, collider: Collider) => boolean): {
+    move(position: Vector3, rotation: ArrayLike<number>, shape: import("../../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D, velocity: Vector3, dt: number, filter: (entity: number, collider: Collider) => boolean): {
         hit: boolean;
         grounded: boolean;
         groundNormal: Vector3;
@@ -226,7 +222,7 @@ export class KinematicMover {
      *       it genuinely swept (`hit.t > skin`, not start-solid in a wall)
      *       and the step is within `stepHeight`.
      *
-     * Reference point is the capsule bottom (`position.y`), matching the
+     * Reference point is the capsule bottom (`position[1]`), matching the
      * feet-at-origin player capsule.
      *
      * @private

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

@@ -1 +1 @@
-{"version":3,"file":"KinematicMover.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/collision/KinematicMover.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA0DI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,2BA9BW,OAAO,uCAAuC,EAAE,aAAa,OAC7D,OAAO,wCAAwC,EAAE,sBAAsB;QAKtD,IAAI,GAArB,MAAM;QAEW,kBAAkB,GAAnC,MAAM;QAEW,oBAAoB,GAArC,MAAM;QAEW,aAAa,GAA9B,MAAM;QAIW,UAAU,GAA3B,MAAM;OAuBhB;IAhGD,WAAkB;IAElB,0BAAiC;IACjC,yBAAkC;IAClC,sBAA8B;IAC9B,sBAAgD;IAChD,oBAA4B;IAC5B,uBAA+B;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAFU;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAgBzJ;IAEF;;;;OAIG;IACH,qBAAqB;IAkCjB,6EAAkC;IAClC,6EAAc;IACd,aAA6D;IAC7D,2BAAmG;IACnG,6BAAyG;IACzG,sBAAsF;IACtF,mBAA6E;IAIjF;;;;;;;;;;;;OAYG;IACH,eATW,OAAO,YACP;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,SACrC,OAAO,mDAAmD,EAAE,eAAe,YAC3E,OAAO,MACP,MAAM,mBACE,MAAM,YAAW,QAAQ,KAAG,OAAO,GAEzC;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA6E7J;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAiGC;IAED;;;;OAIG;IACH,sBAQC;IAED;;;;OAIG;IACH,oBASC;IAED;;;;;;;;;OASG;IACH,iBAwCC;IAED;;;;;;;;OAQG;IACH,eAmIC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,0BAuFC;IAED;;;;;OAKG;IACH,cAKC;CACJ;qBAtsBoB,sCAAsC;oCAIvB,iDAAiD;oBALjE,kCAAkC;yBAG7B,kCAAkC"}
+{"version":3,"file":"KinematicMover.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/collision/KinematicMover.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA0DI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,2BA9BW,OAAO,uCAAuC,EAAE,aAAa,OAC7D,OAAO,wCAAwC,EAAE,sBAAsB;QAKtD,IAAI,GAArB,MAAM;QAEW,kBAAkB,GAAnC,MAAM;QAEW,oBAAoB,GAArC,MAAM;QAEW,aAAa,GAA9B,MAAM;QAIW,UAAU,GAA3B,MAAM;OAuBhB;IAhGD,WAAkB;IAElB,0BAAiC;IACjC,yBAAkC;IAClC,sBAA8B;IAC9B,sBAAgD;IAChD,oBAA4B;IAC5B,uBAA+B;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAFU;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAgBzJ;IAEF;;;;OAIG;IACH,qBAAqB;IAkCjB,6EAAkC;IAClC,6EAAc;IACd,aAA6D;IAC7D,2BAAmG;IACnG,6BAAyG;IACzG,sBAAsF;IACtF,mBAA6E;IAIjF;;;;;;;;;;;;;OAaG;IACH,eAVW,OAAO,YACP,UAAU,MAAM,CAAC,SAEjB,OAAO,mDAAmD,EAAE,eAAe,YAC3E,OAAO,MACP,MAAM,mBACE,MAAM,YAAW,QAAQ,KAAG,OAAO,GAEzC;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA6E7J;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAiGC;IAED;;;;OAIG;IACH,sBAQC;IAED;;;;OAIG;IACH,oBASC;IAED;;;;;;;;;OASG;IACH,iBAwCC;IAED;;;;;;;;OAQG;IACH,eAmIC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,0BAuFC;IAED;;;;;OAKG;IACH,cAKC;CACJ;qBApuBoB,sCAAsC;oCAIvB,iDAAiD;oBALjE,kCAAkC;yBAG7B,kCAAkC"}

package/src/engine/control/first-person/collision/KinematicMover.js

@@ -1,10 +1,39 @@
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { Collider } from "../../../physics/ecs/Collider.js";
 import { compute_penetration } from "../../../physics/narrowphase/compute_penetration.js";
 import { PhysicsSurfacePoint } from "../../../physics/queries/PhysicsSurfacePoint.js";
 
+/**
+ * The mover writes through whatever it was handed, and it is handed a transform's own translation -
+ * a `Float64Array` view with indices rather than `.x`/`.set`. These keep the call sites reading
+ * the way they did.
+ *
+ * @param {number[]|Float64Array} out
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+function v3_write(out, x, y, z) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+}
+
+/**
+ * @param {number[]|Float64Array} out
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+function v3_add_in_place(out, x, y, z) {
+    out[0] += x;
+    out[1] += y;
+    out[2] += z;
+}
+
+
 /**
  * Maximum simultaneous clip planes tracked within a single slide,
  * matching Quake's `MAX_CLIP_PLANES`. A move that contacts more than
@@ -112,7 +141,7 @@ export class KinematicMover {
      * @param {import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem} physicsSystem
      * @param {import("../../../ecs/EntityComponentDataset.js").EntityComponentDataset} ecd
      *   used to resolve an overlapping `body_id` (via
-     *   `physicsSystem.entityOf`) back to its {@link Transform} +
+     *   `physicsSystem.entityOf`) back to its {@link Transform64} +
      *   {@link Collider} for `compute_penetration`.
      * @param {object} [options]
      * @param {number} [options.skin=0.005] clearance left after each
@@ -155,7 +184,8 @@ export class KinematicMover {
      * `velocity` to the corrected value.
      *
      * @param {Vector3} position in/out — current pose, written to the resolved pose
-     * @param {{x:number,y:number,z:number,w:number}} rotation capsule orientation (read)
+     * @param {ArrayLike<number>} rotation capsule orientation as `[x, y, z, w]` (read) - a
+     *   Quaternion is one, and so is a Transform64's rotation
      * @param {import("../../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D} shape convex capsule
      * @param {Vector3} velocity in/out — desired velocity, written to the corrected velocity
      * @param {number} dt
@@ -199,12 +229,12 @@ export class KinematicMover {
         // normal fails the gate), gravity survives, and the body slides down
         // — as feet with no purchase must. A jump (`velocity.y > 0`) is left
         // alone so the launch is never cancelled.
-        if (velocity.y < 0 && this._groundedAt(position.x, position.y, position.z, filter)) {
+        if (velocity.y < 0 && this._groundedAt(position[0], position[1], position[2], filter)) {
             velocity.y = 0;
         }
 
         // Snapshot pre-slide state for a possible stair step-up retry.
-        const sx = position.x, sy = position.y, sz = position.z;
+        const sx = position[0], sy = position[1], sz = position[2];
         const svx = velocity.x, svy = velocity.y, svz = velocity.z;
 
         // 2. Sweep-and-slide the desired motion.
@@ -263,8 +293,8 @@ export class KinematicMover {
         // could climb a wall by jumping into it).
         if (!this._groundedAt(sx, sy, sz, filter)) return;
 
-        const slideProg = (position.x - sx) * (position.x - sx) + (position.z - sz) * (position.z - sz);
-        const px = position.x, py = position.y, pz = position.z;
+        const slideProg = (position[0] - sx) * (position[0] - sx) + (position[2] - sz) * (position[2] - sz);
+        const px = position[0], py = position[1], pz = position[2];
         const pvx = velocity.x, pvy = velocity.y, pvz = velocity.z;
         const fnx = hdx / forwardLen, fnz = hdz / forwardLen; // travel direction
 
@@ -321,12 +351,12 @@ export class KinematicMover {
 
         // Confirmed climbable (nothing crosses the step-height plane ahead).
         // Up–forward–down places the capsule onto the step top.
-        position.set(sx, sy, sz);
+        v3_write(position, sx, sy, sz);
         const up = this._castDistance(position, rotation, shape, 0, 1, 0, this.stepHeight, filter);
-        position._add(0, up, 0);
-        position._add(fnx * forwardLen, 0, fnz * forwardLen);
+        v3_add_in_place(position, 0, up, 0);
+        v3_add_in_place(position, fnx * forwardLen, 0, fnz * forwardLen);
         const down = this._castDistance(position, rotation, shape, 0, -1, 0, up + this.skin, filter);
-        position._add(0, -down, 0);
+        v3_add_in_place(position, 0, -down, 0);
 
         // Reject a climb that ends INSIDE geometry. The thin step-height
         // probe is a single ray, so at a convex CORNER it can thread past
@@ -336,8 +366,8 @@ export class KinematicMover {
         // body on that corner, overlapping it. A genuine step top is rested
         // on `skin` ABOVE, never overlapping; so an overlap at the
         // destination is the tell that we climbed onto a wall, not a step.
-        const stepProg = (position.x - sx) * (position.x - sx) + (position.z - sz) * (position.z - sz);
-        const heightGain = position.y - sy;
+        const stepProg = (position[0] - sx) * (position[0] - sx) + (position[2] - sz) * (position[2] - sz);
+        const heightGain = position[1] - sy;
         const overlaps = this.physicsSystem.overlap(shape, position, rotation, this._overlapBuf, 0, filter) > 0;
         if (stepProg > slideProg + 1e-8 && heightGain <= this.stepHeight + this.skin && !overlaps) {
             velocity.set(svx, svy, svz); // restore horizontal; vertical settled by categorize
@@ -349,7 +379,7 @@ export class KinematicMover {
                 result.stepUp = heightGain > 0 ? heightGain : 0;
             }
         } else {
-            position.set(px, py, pz);
+            v3_write(position, px, py, pz);
             velocity.set(pvx, pvy, pvz);
         }
     }
@@ -361,7 +391,7 @@ export class KinematicMover {
      */
     _castDistance(position, rotation, shape, dx, dy, dz, maxDist, filter) {
         const ray = this._ray;
-        ray.setOrigin(position.x, position.y, position.z);
+        ray.setOrigin(position[0], position[1], position[2]);
         ray.setDirection(dx, dy, dz);
         ray.tMax = maxDist;
         if (!this.physicsSystem.shapeCast(ray, shape, rotation, this._hit, filter)) return maxDist;
@@ -412,7 +442,7 @@ export class KinematicMover {
                 const bodyId = buf[i];
                 const entity = physics.entityOf(bodyId);
                 if (entity < 0) continue;
-                const otherT = ecd.getComponent(entity, Transform);
+                const otherT = ecd.getComponent(entity, Transform64);
                 const otherC = ecd.getComponent(entity, Collider);
                 if (otherT === undefined || otherC === undefined) continue;
 
@@ -420,7 +450,7 @@ export class KinematicMover {
                 const depth = compute_penetration(
                     dir,
                     shape, position, rotation,
-                    otherC.shape, otherT.position, otherT.rotation,
+                    otherC.shape, otherT.translation, otherT.rotation,
                 );
                 if (depth > bestDepth) {
                     bestDepth = depth;
@@ -433,7 +463,7 @@ export class KinematicMover {
             if (bestDepth <= 0) return;
 
             const push = bestDepth + this.skin;
-            position._add(bestX * push, bestY * push, bestZ * push);
+            v3_add_in_place(position, bestX * push, bestY * push, bestZ * push);
         }
     }
 
@@ -471,7 +501,7 @@ export class KinematicMover {
             const inv = 1 / speed;
             const ndx = vx * inv, ndy = vy * inv, ndz = vz * inv;
 
-            ray.setOrigin(position.x, position.y, position.z);
+            ray.setOrigin(position[0], position[1], position[2]);
             ray.setDirection(ndx, ndy, ndz);
             ray.tMax = len;
 
@@ -479,7 +509,7 @@ export class KinematicMover {
 
             if (!didHit) {
                 // Clear path — consume the whole remaining move.
-                position._add(ndx * len, ndy * len, ndz * len);
+                v3_add_in_place(position, ndx * len, ndy * len, ndz * len);
                 break;
             }
 
@@ -494,7 +524,7 @@ export class KinematicMover {
             // reachable by moving INTO it (dir·n < 0).
             const dirDotN = ndx * hit.normal.x + ndy * hit.normal.y + ndz * hit.normal.z;
             if (dirDotN >= 0) {
-                position._add(ndx * len, ndy * len, ndz * len);
+                v3_add_in_place(position, ndx * len, ndy * len, ndz * len);
                 break;
             }
 
@@ -503,7 +533,7 @@ export class KinematicMover {
             // Advance up to the contact (less skin), and consume the
             // corresponding fraction of the remaining time.
             const advance = hit.t - skin > 0 ? hit.t - skin : 0;
-            if (advance > 0) position._add(ndx * advance, ndy * advance, ndz * advance);
+            if (advance > 0) v3_add_in_place(position, ndx * advance, ndy * advance, ndz * advance);
             const fraction = hit.t / len; // time uses the true TOI, not the skinned advance
             timeLeft -= timeLeft * (fraction > 1 ? 1 : fraction);
 
@@ -603,7 +633,7 @@ export class KinematicMover {
      *       it genuinely swept (`hit.t > skin`, not start-solid in a wall)
      *       and the step is within `stepHeight`.
      *
-     * Reference point is the capsule bottom (`position.y`), matching the
+     * Reference point is the capsule bottom (`position[1]`), matching the
      * feet-at-origin player capsule.
      *
      * @private
@@ -626,7 +656,7 @@ export class KinematicMover {
         let nx = 0, ny = 1, nz = 0;
         let haveCentre = false;
         let centreSurfaceY = 0;
-        ray.setOrigin(position.x, position.y + lift, position.z);
+        ray.setOrigin(position[0], position[1] + lift, position[2]);
         ray.setDirection(0, -1, 0);
         ray.tMax = reach;
         if (this.physicsSystem.raycast(ray, hit, filter)) {
@@ -635,7 +665,7 @@ export class KinematicMover {
                 result.groundNormal.set(nx, ny, nz);
                 return; // steep slope under the feet — slide, not grounded
             }
-            centreSurfaceY = position.y + lift - hit.t; // the planar ground under the feet
+            centreSurfaceY = position[1] + lift - hit.t; // the planar ground under the feet
             haveCentre = true;
         }
 
@@ -647,13 +677,13 @@ export class KinematicMover {
         //     floor the centre sees, never mounts and a capsule that rode up
         //     snaps back), else `feet − stepHeight` (so any footprint within
         //     the stick band, but no higher than the feet, supports us).
-        const base = haveCentre ? centreSurfaceY : (position.y - this.stepHeight);
+        const base = haveCentre ? centreSurfaceY : (position[1] - this.stepHeight);
         let surfaceY = haveCentre ? centreSurfaceY : Number.NEGATIVE_INFINITY;
-        ray.setOrigin(position.x, position.y + lift, position.z);
+        ray.setOrigin(position[0], position[1] + lift, position[2]);
         ray.setDirection(0, -1, 0);
         ray.tMax = reach;
         if (this.physicsSystem.shapeCast(ray, shape, rotation, hit, filter) && hit.t > this.skin) {
-            const stepY = position.y + lift - hit.t;
+            const stepY = position[1] + lift - hit.t;
             // With a centre surface the centre ray already vouched for
             // walkability, so mount any step. With NONE, the footprint is the
             // sole ground source — accept it only if it's a WALKABLE rest (a
@@ -683,7 +713,7 @@ export class KinematicMover {
 
         // Stick: rest the feet `skin` above the surface (snaps down for a
         // descent, up onto a step / out of a grazing contact).
-        position.y = surfaceY + this.skin;
+        position[1] = surfaceY + this.skin;
 
         // Clip the into-ground velocity component (gravity on flat ground;
         // the into-slope part on a ramp), leaving tangential motion.

package/src/engine/control/first-person/sensors/FirstPersonSensorsSystem.d.ts

@@ -21,7 +21,7 @@
  */
 export class FirstPersonSensorsSystem extends System<any> {
     constructor();
-    dependencies: (typeof Transform | typeof FirstPersonPlayerController)[];
+    dependencies: (typeof Transform64 | typeof FirstPersonPlayerController)[];
     /**
      * Reference to the controller system — needed to look up each
      * entity's per-controller runtime (which owns the sensors slot).
@@ -81,7 +81,7 @@ export class FirstPersonSensorsSystem extends System<any> {
     private _probeRay;
 }
 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 { FirstPersonPlayerControllerSystem } from "../FirstPersonPlayerControllerSystem.js";
 import { PhysicsSystem } from "../../../physics/ecs/PhysicsSystem.js";

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

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,wEAAwD;IAExD;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAsFC;IAED;;;;;;OAMG;IACH,wBASC;IAED;;;;;;;;;;;OAWG;IACH,kBAiBC;CACJ;uBA/NsB,wBAAwB;0BACrB,qCAAqC;4CACnB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}
+{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,0EAA0D;IAE1D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAsFC;IAED;;;;;;OAMG;IACH,wBASC;IAED;;;;;;;;;;;OAWG;IACH,kBAiBC;CACJ;uBA/NsB,wBAAwB;4BACnB,uCAAuC;4CACvB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}

package/src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js

@@ -3,7 +3,7 @@ import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
 import { PhysicsSystem } from "../../../physics/ecs/PhysicsSystem.js";
 import { PhysicsSurfacePoint } from "../../../physics/queries/PhysicsSurfacePoint.js";
 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 { FirstPersonPlayerControllerSystem } from "../FirstPersonPlayerControllerSystem.js";
 
@@ -29,7 +29,7 @@ import { FirstPersonPlayerControllerSystem } from "../FirstPersonPlayerControlle
  * @copyright Company Named Limited (c) 2026
  */
 export class FirstPersonSensorsSystem extends System {
-    dependencies = [FirstPersonPlayerController, Transform];
+    dependencies = [FirstPersonPlayerController, Transform64];
 
     /**
      * Reference to the controller system — needed to look up each
@@ -108,7 +108,7 @@ export class FirstPersonSensorsSystem extends System {
             + "explicitly.");
 
         const ecd = this.entityManager.dataset;
-        const transform = ecd.getComponent(entity, Transform);
+        const transform = ecd.getComponent(entity, Transform64);
         if (transform === undefined) return;
 
         sensors.clearAll();
@@ -116,9 +116,9 @@ export class FirstPersonSensorsSystem extends System {
         // Probe origin: at chest height (approx body height × 0.65).
         const cfg = controller.config;
         const chestY = cfg.body.height * 0.65;
-        const ox = transform.position.x;
-        const oy = transform.position.y + chestY;
-        const oz = transform.position.z;
+        const ox = transform.translation_x;
+        const oy = transform.translation_y + chestY;
+        const oz = transform.translation_z;
 
         // Body-local forward + right (engine-local axes — see DESIGN.md
         // §5.3 for the conventions). bodyYaw lives on the runtime.
@@ -149,7 +149,7 @@ export class FirstPersonSensorsSystem extends System {
         // around chest height: probe down from just past the top of the
         // obstacle, look for ground.
         if (sensors.obstacleAhead.hit) {
-            const topY = transform.position.y + cfg.body.height + 0.1;
+            const topY = transform.translation_y + cfg.body.height + 0.1;
             const px = sensors.obstacleAhead.point.x + fx * 0.3;
             const pz = sensors.obstacleAhead.point.z + fz * 0.3;
             this._probeRay(

package/src/engine/ecs/EventType.d.ts

@@ -6,5 +6,6 @@ export namespace EventType {
     let EntityRemoved: string;
     let ComponentAdded: string;
     let ComponentRemoved: string;
+    let ComponentChanged: string;
 }
 //# sourceMappingURL=EventType.d.ts.map

package/src/engine/ecs/EventType.js

@@ -1,10 +1,35 @@
-/**
- * Special set of ECD events
- * @enum {string}
- * @readonly
- */
-export const EventType = {
-    EntityRemoved: "entityRemoved",
-    ComponentAdded: "componentAdded",
-    ComponentRemoved: "componentRemoved"
-};
+/**
+ * Special set of ECD events
+ * @enum {string}
+ * @readonly
+ */
+export const EventType = {
+    EntityRemoved: "entityRemoved",
+    ComponentAdded: "componentAdded",
+    ComponentRemoved: "componentRemoved",
+    /**
+     * A component's contents were mutated in place, by whoever mutated them.
+     *
+     * Payload is `{ klass, instance }`, the same shape {@link EventType.ComponentAdded} and
+     * {@link EventType.ComponentRemoved} carry, so the three together describe a component's whole
+     * lifecycle on one channel.
+     *
+     * The dataset never sends this on its own: it cannot know when a caller has finished mutating a
+     * component, so announcing the change is the writer's job.
+     * ```
+     * ecd.sendEvent(entity, EventType.ComponentChanged, { klass: Transform64, instance: t64 });
+     * ```
+     *
+     * Deliberately coarse - it says *that* the component changed, not *what* changed. A component
+     * whose contents are rewritten wholesale, as {@link Transform64#multiplyTransforms} rewrites a
+     * transform, has no finer answer to give, and a per-field axis running beside this one would be
+     * a second mechanism describing the same lifecycle. Working out what moved is the consumer's
+     * problem, and reacting to a superset of what it cares about is expected: a consumer woken by a
+     * rotation write when it only tracks translation does redundant work, not wrong work. Where
+     * redundant work is too expensive, that one consumer retains a copy and compares against it.
+     *
+     * @see EntityComponentDataset#sendEvent
+     * @see EntityComponentDataset#addEntityEventListener
+     */
+    ComponentChanged: "componentChanged"
+};

package/src/engine/ecs/dynamic_actions/actions/definition/SendRequestActionDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SendRequestActionDescription.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/dynamic_actions/actions/definition/SendRequestActionDescription.js"],"names":[],"mappings":"AAMA;IAGI,iBAAoC;IACpC,mBAAe;IACf,YAAa;IAEb;;;;aAaC;IAED,kFAsEC;CACJ;0CA/FyC,gCAAgC;+BAF3C,+DAA+D"}
+{"version":3,"file":"SendRequestActionDescription.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/dynamic_actions/actions/definition/SendRequestActionDescription.js"],"names":[],"mappings":"AAOA;IAGI,iBAAoC;IACpC,mBAAe;IACf,YAAa;IAEb;;;;aAaC;IAED,kFA6EC;CACJ;0CAtGyC,gCAAgC;+BAH3C,+DAA+D"}

package/src/engine/ecs/dynamic_actions/actions/definition/SendRequestActionDescription.js

@@ -1,7 +1,8 @@
 import { assert } from "../../../../../core/assert.js";
 import { compileReactiveExpression } from "../../../../../core/lang/reactive/compileReactiveExpression.js";
 import { ActionBehavior } from "../../../../intelligence/behavior/primitive/ActionBehavior.js";
-import { Transform } from "../../../transform/Transform.js";
+import { v3_distance } from "../../../../../core/geom/vec3/v3_distance.js";
+import { Transform64 } from "../../../transform/Transform64.js";
 import { AbstractActionDescription } from "./AbstractActionDescription.js";
 
 export class SendRequestActionDescription extends AbstractActionDescription {
@@ -64,20 +65,27 @@ export class SendRequestActionDescription extends AbstractActionDescription {
                     return true;
                 }
 
-                const actor_transform = ecd.getComponent(actor, Transform);
+                const actor_transform = ecd.getComponent(actor, Transform64);
 
 
                 if (actor_transform === undefined) {
                     return true;
                 }
 
-                const target_transform = ecd.getComponent(entity, Transform);
+                const target_transform = ecd.getComponent(entity, Transform64);
 
                 if (target_transform === undefined) {
                     return false;
                 }
 
-                return target_transform.position.distanceTo(actor_transform.position) <= distance;
+                return v3_distance(
+                    target_transform.translation_x,
+                    target_transform.translation_y,
+                    target_transform.translation_z,
+                    actor_transform.translation_x,
+                    actor_transform.translation_y,
+                    actor_transform.translation_z
+                ) <= distance;
             }
 
             const bestActors = system.requestBestActors(action_context, filter, this, this.responders);

package/src/engine/ecs/fow/FogOfWarRevealerSystem.d.ts

@@ -4,7 +4,7 @@ export class FogOfWarRevealerSystem extends System<any> {
      * @param {number} team
      */
     constructor(team: number);
-    dependencies: (typeof Transform | typeof FogOfWarRevealer | typeof Team)[];
+    dependencies: (typeof Transform64 | typeof FogOfWarRevealer | typeof Team)[];
     components_used: ResourceAccessSpecification<typeof FogOfWar>[];
     data: any[];
     /**
@@ -15,16 +15,16 @@ export class FogOfWarRevealerSystem extends System<any> {
     /**
      *
      * @param {FogOfWarRevealer} revealer
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {Team} team
      * @param entity
      */
-    link(revealer: FogOfWarRevealer, transform: Transform, team: Team, entity: any): void;
+    link(revealer: FogOfWarRevealer, transform: Transform64, team: Team, entity: any): void;
     forceUpdate(): void;
     unlink(revealer: any, position: any, team: any, entity: any): void;
 }
 import { System } from "../System.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 import { FogOfWarRevealer } from "./FogOfWarRevealer.js";
 import Team from "../team/Team.js";
 import { FogOfWar } from "./FogOfWar.js";

package/src/engine/ecs/fow/FogOfWarRevealerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarRevealerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarRevealerSystem.js"],"names":[],"mappings":"AAaA;IAOI;;;OAGG;IACH,kBAFW,MAAM,EAUhB;IAlBD,2EAAmD;IACnD,gEAEE;IACF,YAAU;IASN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;;;;;OAMG;IACH,eALW,gBAAgB,aAChB,SAAS,QACT,IAAI,qBA2Dd;IAED,oBAmCC;IAED,mEAMC;CACJ;uBA/IsB,cAAc;0BAKX,2BAA2B;iCAJpB,uBAAuB;iBAGvC,iBAAiB;yBADT,eAAe;4CAKI,oDAAoD"}
+{"version":3,"file":"FogOfWarRevealerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarRevealerSystem.js"],"names":[],"mappings":"AAaA;IAOI;;;OAGG;IACH,kBAFW,MAAM,EAUhB;IAlBD,6EAAqD;IACrD,gEAEE;IACF,YAAU;IASN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;;;;;OAMG;IACH,eALW,gBAAgB,aAChB,WAAW,QACX,IAAI,qBA0Dd;IAED,oBAmCC;IAED,mEAMC;CACJ;uBA9IsB,cAAc;4BAKT,6BAA6B;iCAJxB,uBAAuB;iBAGvC,iBAAiB;yBADT,eAAe;4CAKI,oDAAoD"}

package/src/engine/ecs/fow/FogOfWarRevealerSystem.js

@@ -3,7 +3,7 @@ import { FogOfWarRevealer } from "./FogOfWarRevealer.js";
 import { SignalBinding } from "../../../core/events/signal/SignalBinding.js";
 import { FogOfWar } from "./FogOfWar.js";
 import Team from "../team/Team.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
@@ -12,7 +12,7 @@ import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 const v2 = new Vector2();
 
 export class FogOfWarRevealerSystem extends System {
-    dependencies = [FogOfWarRevealer, Transform, Team];
+    dependencies = [FogOfWarRevealer, Transform64, Team];
     components_used = [
         ResourceAccessSpecification.from(FogOfWar, ResourceAccessKind.Write)
     ];
@@ -35,7 +35,7 @@ export class FogOfWarRevealerSystem extends System {
     /**
      *
      * @param {FogOfWarRevealer} revealer
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {Team} team
      * @param entity
      */
@@ -44,9 +44,6 @@ export class FogOfWarRevealerSystem extends System {
 
         const visibilityTeam = this.team;
 
-        const position = transform.position;
-
-
         function update() {
             const dataset = em.dataset;
 
@@ -56,7 +53,9 @@ export class FogOfWarRevealerSystem extends System {
 
                 if (terrain !== null) {
 
-                    terrain.mapPointWorld2Grid(position, v2);
+                    terrain.mapPointWorld2Grid(
+                        transform.translation_x, transform.translation_z, v2
+                    );
 
                     dataset.traverseComponents(FogOfWar, function (fow) {
                         fow.reveal(v2.x, v2.y, revealer.radius.getValue());
@@ -114,17 +113,17 @@ export class FogOfWarRevealerSystem extends System {
                 fows.push(fow);
             });
 
-            dataset.traverseEntities([FogOfWarRevealer, Transform, Team], (revealer, transform, team) => {
+            dataset.traverseEntities([FogOfWarRevealer, Transform64, Team], (revealer, transform, team) => {
                 if (team.getValue() !== this.team) {
                     // wrong team
                     return;
                 }
 
-                const position = transform.position;
-
                 if (terrain !== null) {
 
-                    terrain.mapPointWorld2Grid(position, v2);
+                    terrain.mapPointWorld2Grid(
+                        transform.translation_x, transform.translation_z, v2
+                    );
 
                     fows.forEach(function (fow) {
                         fow.reveal(v2.x, v2.y, revealer.radius.getValue());

package/src/engine/ecs/grid/pick.js

@@ -36,7 +36,7 @@ export function pick(x, y, graphicsEngine, terrain, callback) {
     } else {
 
         const gridPosition = new Vector2();
-        terrain.mapPointWorld2Grid(surfacePoint3.position, gridPosition);
+        terrain.mapPointWorld2Grid(surfacePoint3.position.x, surfacePoint3.position.z, gridPosition);
         gridPosition._add(0.5, 0.5);
         callback(gridPosition, surfacePoint3.position, surfacePoint3.normal);
     }

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.d.ts

@@ -27,7 +27,7 @@ declare class HeadsUpDisplaySystem extends System<any> {
      * The quaternion rotation is NOT inlined — {@link v3_quaternion_apply} already writes into a caller-supplied
      * array, so it costs no allocation and there is nothing to gain from a private copy of the expansion.
      * @param {HeadsUpDisplay} hud
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {ViewportPosition} vp
      * @param {GUIElement} element
      * @private