@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/ecs/transform-attachment/TransformAttachment.d.ts

@@ -2,7 +2,7 @@ export namespace TransformAttachmentFlags {
     let Immediate: number;
 }
 /**
- * Controls {@link Transform} the entity it is attached to, enables transformation hierarchy.
+ * Controls {@link Transform64} the entity it is attached to, enables transformation hierarchy.
  *
  * This is the *spatial* relation only. It says where the entity is, never how long it lives — see
  * {@link ParentEntity} for that, and note that the two are free to name different entities, which is
@@ -27,9 +27,9 @@ export class TransformAttachment {
     /**
      * Transform relative to the attachment target.
      * Think of this as "local transform".
-     * @type {Transform}
+     * @type {Transform64}
      */
-    transform: Transform;
+    transform: Transform64;
     /**
      * Which entity to attach to, this is what our transform is relative to.
      * Must not be mutated (changed) while the component is attached to a dataset.
@@ -50,7 +50,7 @@ export class TransformAttachment {
     toString(): string;
     toJSON(): {
         transform: {
-            position: {
+            translation: {
                 x: number;
                 y: number;
                 z: number;
@@ -138,5 +138,5 @@ export class TransformAttachment {
 export namespace TransformAttachment {
     let typeName: string;
 }
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 //# sourceMappingURL=TransformAttachment.d.ts.map

package/src/engine/ecs/transform-attachment/TransformAttachment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachment.js"],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;;;OAIG;IACH,WAFU,SAAS,CAES;IAE5B;;;;;;;;;;OAUG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB,mBAEC;IAED;;;;;;;;;;;;;;;;;;;;;MAMC;IAED;;;;aAQC;IAMD;;;OAGG;IACH,4BAEC;IAVD,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM;QA/FjB;;;WAGG;;KA4FuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAxGjB;;;WAGG;;KAqGuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAjHjB;;;WAGG;;KA8GuC,SAC/B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;QA9HjB;;;WAGG;;KA2HuC,GAC7B,OAAO,CAInB;IAUL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CAZlD;;kBAIS,MAAM;;0BA5IU,2BAA2B"}
+{"version":3,"file":"TransformAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachment.js"],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;;;OAIG;IACH,WAFU,WAAW,CAES;IAE9B;;;;;;;;;;OAUG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB,mBAEC;IAED;;;;;;;;;;;;;;;;;;;;;MAMC;IAED;;;;aAQC;IAMD;;;OAGG;IACH,4BAEC;IAVD,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM;QA/FjB;;;WAGG;;KA4FuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAxGjB;;;WAGG;;KAqGuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAjHjB;;;WAGG;;KA8GuC,SAC/B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;QA9HjB;;;WAGG;;KA2HuC,GAC7B,OAAO,CAInB;IAUL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CAZlD;;kBAIS,MAAM;;4BA5IY,6BAA6B"}

package/src/engine/ecs/transform-attachment/TransformAttachment.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 
 export const TransformAttachmentFlags = {
     /**
@@ -12,7 +12,7 @@ export const TransformAttachmentFlags = {
 const DEFAULT_FLAGS = TransformAttachmentFlags.Immediate;
 
 /**
- * Controls {@link Transform} the entity it is attached to, enables transformation hierarchy.
+ * Controls {@link Transform64} the entity it is attached to, enables transformation hierarchy.
  *
  * This is the *spatial* relation only. It says where the entity is, never how long it lives — see
  * {@link ParentEntity} for that, and note that the two are free to name different entities, which is
@@ -38,9 +38,9 @@ export class TransformAttachment {
     /**
      * Transform relative to the attachment target.
      * Think of this as "local transform".
-     * @type {Transform}
+     * @type {Transform64}
      */
-    transform = new Transform();
+    transform = new Transform64();
 
     /**
      * Which entity to attach to, this is what our transform is relative to.

package/src/engine/ecs/transform-attachment/TransformAttachmentSystem.d.ts

@@ -1,6 +1,6 @@
 /**
  * Owns the *spatial* hierarchy: an entity carrying {@link TransformAttachment} has its world
- * {@link Transform} composed as parent world × local.
+ * {@link Transform64} composed as parent world × local.
  *
  * The component stores only the child-to-parent direction, so the system keeps the other one, in the
  * same shape {@link ParentEntitySystem} keeps for the lifetime hierarchy.
@@ -12,7 +12,7 @@
  * - **Children come back ascending by entity id**, not in link order. See {@link EntityChildIndex}.
  * - **Callers get a snapshot**, because detaching or destroying what a child list names moves the
  *   index under a caller that is iterating it.
- * - **A queued child is in the index.** A child whose parent has no {@link Transform} yet is parked
+ * - **A queued child is in the index.** A child whose parent has no {@link Transform64} yet is parked
  *   and retried, and it is indexed from the moment it links rather than from the moment it binds:
  *   the question the index answers is "which children point at me", and that is true of a child that
  *   is still waiting. The consequence is that a non-zero child count does not imply those children
@@ -49,8 +49,8 @@ export class TransformAttachmentSystem extends System<any> {
     private __queue;
     __queue_size: number;
     __queue_cursor: number;
-    dependencies: (typeof Transform | typeof TransformAttachment)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof TransformAttachment>)[];
+    dependencies: (typeof Transform64 | typeof TransformAttachment)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof TransformAttachment>)[];
     /**
      *
      * @param {UpdateContext} ctx
@@ -72,7 +72,7 @@ export class TransformAttachmentSystem extends System<any> {
     private __dequeue_entity;
     /**
      * Direct children of `entity`, ascending by entity id. Includes children that are still queued
-     * waiting for this entity to gain a {@link Transform}.
+     * waiting for this entity to gain a {@link Transform64}.
      *
      * @param {number[]} result written from `result_offset` onwards
      * @param {number} result_offset
@@ -91,21 +91,21 @@ export class TransformAttachmentSystem extends System<any> {
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(attachment: TransformAttachment, transform: Transform, entity: number): void;
+    link(attachment: TransformAttachment, transform: Transform64, entity: number): void;
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(attachment: TransformAttachment, transform: Transform, entity: number): void;
+    unlink(attachment: TransformAttachment, transform: Transform64, entity: number): void;
     update(timeDelta: any): void;
 }
 import { System } from "../System.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 import { TransformAttachment } from "./TransformAttachment.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 //# sourceMappingURL=TransformAttachmentSystem.d.ts.map

package/src/engine/ecs/transform-attachment/TransformAttachmentSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformAttachmentSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachmentSystem.js"],"names":[],"mappings":"AA8IA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;IAEI;;;;OAIG;IACH,mBAAgB;IAEhB;;;;;OAKG;IACH,mBAAoC;IAEpC;;;;OAIG;IACH,gBAAa;IACb,qBAAiB;IACjB,uBAAmB;IAEnB,gEAAgD;IAChD,6HAGE;IAEF;;;;OAIG;IACH,wBASC;IAED;;;;OAIG;IACH,kBAEC;IAED;;;;;OAKG;IACH,yBAYC;IAED;;;;;;;;OAQG;IACH,uBALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iBAJW,mBAAmB,aACnB,SAAS,UACT,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,mBAJW,mBAAmB,aACnB,SAAS,UACT,MAAM,QAkBhB;IAED,6BAoBC;CACJ;uBAnVsB,cAAc;0BACX,2BAA2B;oCACS,0BAA0B;4CAL5C,oDAAoD"}
+{"version":3,"file":"TransformAttachmentSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachmentSystem.js"],"names":[],"mappings":"AAiMA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;IAEI;;;;OAIG;IACH,mBAAgB;IAEhB;;;;;OAKG;IACH,mBAAoC;IAEpC;;;;OAIG;IACH,gBAAa;IACb,qBAAiB;IACjB,uBAAmB;IAEnB,kEAAkD;IAClD,+HAGE;IAEF;;;;OAIG;IACH,wBASC;IAED;;;;OAIG;IACH,kBAEC;IAED;;;;;OAKG;IACH,yBAYC;IAED;;;;;;;;OAQG;IACH,uBALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iBAJW,mBAAmB,aACnB,WAAW,UACX,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,mBAJW,mBAAmB,aACnB,WAAW,UACX,MAAM,QAkBhB;IAED,6BAoBC;CACJ;uBAtYsB,cAAc;4BACT,6BAA6B;oCACK,0BAA0B;4CAL5C,oDAAoD"}

package/src/engine/ecs/transform-attachment/TransformAttachmentSystem.js

@@ -4,7 +4,7 @@ import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessS
 import { EventType } from "../EventType.js";
 import { EntityChildIndex } from "../hierarchy/EntityChildIndex.js";
 import { System } from "../System.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 import { TransformAttachment, TransformAttachmentFlags } from "./TransformAttachment.js";
 
 /**
@@ -22,7 +22,7 @@ class UpdateContext {
 
     /**
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     transform = null;
 
@@ -34,7 +34,7 @@ class UpdateContext {
 
     /**
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     parent_transform = null;
 
@@ -65,6 +65,19 @@ class UpdateContext {
             this.parent_transform,
             this.attachment.transform
         );
+
+        /*
+         This is what carries a move down a chain. The world transform just written is what this
+         entity's OWN children compose against, and they are listening for exactly this event; a
+         Transform64 says nothing when it is written, so the composition says it instead.
+
+         Note that nothing here listens to this: reacting to your own output is a loop, which is
+         why the self-listener below is about the attachment only.
+        */
+        this.ecd.sendEvent(this.entity, EventType.ComponentChanged, {
+            klass: Transform64,
+            instance: this.transform
+        });
     }
 
     /**
@@ -73,7 +86,7 @@ class UpdateContext {
      */
     bind_parent() {
 
-        const parent_transform = this.ecd.getComponent(this.attachment.parent, Transform);
+        const parent_transform = this.ecd.getComponent(this.attachment.parent, Transform64);
 
         if (parent_transform === undefined) {
             return false;
@@ -87,7 +100,7 @@ class UpdateContext {
     /**
      * The spatial parent is gone, so there is nothing left to compose against. Dropping the component
      * is what turns that into an observable state change: the entity keeps the world transform it had
-     * and becomes a root, instead of silently freezing while holding a dead parent's {@link Transform}
+     * and becomes a root, instead of silently freezing while holding a dead parent's {@link Transform64}
      * alive through this context.
      *
      * @returns {void}
@@ -101,14 +114,40 @@ class UpdateContext {
         this.ecd.removeComponentFromEntity(this.entity, TransformAttachment);
     }
 
+    /** @type {function(*)|null} */
+    #on_parent_changed = null;
+
+    /** @type {function(*)|null} */
+    #on_self_changed = null;
+
     link() {
-        const t_parent = this.parent_transform;
+        // Neither transform carries signals any more, so both announcements come through the
+        // dataset. The parent's pose arrives as a change to its own Transform64 - whether the
+        // parent is a root somebody moved or a link whose own composition just ran; the attachment's
+        // offset arrives as a change to the TransformAttachment component holding it.
+        this.#on_parent_changed = event => {
+            if (event.klass === Transform64) {
+                this.update();
+            }
+        };
 
-        t_parent.subscribe(this.update, this);
+        this.#on_self_changed = event => {
+            if (event.klass === TransformAttachment) {
+                this.update();
+            }
+        };
 
-        const t_attachment = this.attachment.transform;
+        this.ecd.addEntityEventListener(
+            this.attachment.parent,
+            EventType.ComponentChanged,
+            this.#on_parent_changed
+        );
 
-        t_attachment.subscribe(this.update, this);
+        this.ecd.addEntityEventListener(
+            this.entity,
+            EventType.ComponentChanged,
+            this.#on_self_changed
+        );
 
         this.ecd.addEntityEventListener(
             this.attachment.parent,
@@ -123,13 +162,25 @@ class UpdateContext {
     unlink() {
         this.#linked = false;
 
-        const transform = this.parent_transform;
+        if (this.#on_parent_changed !== null) {
+            this.ecd.removeEntityEventListener(
+                this.attachment.parent,
+                EventType.ComponentChanged,
+                this.#on_parent_changed
+            );
 
-        transform.unsubscribe(this.update, this);
+            this.#on_parent_changed = null;
+        }
 
-        const t_attachment = this.attachment.transform;
+        if (this.#on_self_changed !== null) {
+            this.ecd.removeEntityEventListener(
+                this.entity,
+                EventType.ComponentChanged,
+                this.#on_self_changed
+            );
 
-        t_attachment.unsubscribe(this.update, this);
+            this.#on_self_changed = null;
+        }
 
         this.ecd.removeEntityEventListener(
             this.attachment.parent,
@@ -142,7 +193,7 @@ class UpdateContext {
 
 /**
  * Owns the *spatial* hierarchy: an entity carrying {@link TransformAttachment} has its world
- * {@link Transform} composed as parent world × local.
+ * {@link Transform64} composed as parent world × local.
  *
  * The component stores only the child-to-parent direction, so the system keeps the other one, in the
  * same shape {@link ParentEntitySystem} keeps for the lifetime hierarchy.
@@ -154,7 +205,7 @@ class UpdateContext {
  * - **Children come back ascending by entity id**, not in link order. See {@link EntityChildIndex}.
  * - **Callers get a snapshot**, because detaching or destroying what a child list names moves the
  *   index under a caller that is iterating it.
- * - **A queued child is in the index.** A child whose parent has no {@link Transform} yet is parked
+ * - **A queued child is in the index.** A child whose parent has no {@link Transform64} yet is parked
  *   and retried, and it is indexed from the moment it links rather than from the moment it binds:
  *   the question the index answers is "which children point at me", and that is true of a child that
  *   is still waiting. The consequence is that a non-zero child count does not imply those children
@@ -194,10 +245,10 @@ export class TransformAttachmentSystem extends System {
     __queue_size = 0;
     __queue_cursor = 0;
 
-    dependencies = [TransformAttachment, Transform];
+    dependencies = [TransformAttachment, Transform64];
     components_used = [
         ResourceAccessSpecification.from(TransformAttachment, ResourceAccessKind.Read),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read | ResourceAccessKind.Write),
     ];
 
     /**
@@ -247,7 +298,7 @@ export class TransformAttachmentSystem extends System {
 
     /**
      * Direct children of `entity`, ascending by entity id. Includes children that are still queued
-     * waiting for this entity to gain a {@link Transform}.
+     * waiting for this entity to gain a {@link Transform64}.
      *
      * @param {number[]} result written from `result_offset` onwards
      * @param {number} result_offset
@@ -272,7 +323,7 @@ export class TransformAttachmentSystem extends System {
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     link(attachment, transform, entity) {
@@ -300,7 +351,7 @@ export class TransformAttachmentSystem extends System {
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     unlink(attachment, transform, entity) {

package/src/engine/graphics/debug/createDebugLabel.js

@@ -1,5 +1,5 @@
 import Vector3 from "../../../core/geom/Vector3.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 import Entity from "../../ecs/Entity.js";
 import HeadsUpDisplay from "../../ecs/gui/hud/HeadsUpDisplay.js";
 import ViewportPosition from "../../ecs/gui/position/ViewportPosition.js";
@@ -22,9 +22,9 @@ export function createDebugLabel(text, position = Vector3.zero) {
         top: 0
     })
 
-    const t = new Transform();
+    const t = new Transform64();
 
-    t.position.copy(position);
+    t.setTranslation(position.x, position.y, position.z);
 
     const eb = new Entity()
         .add(new HeadsUpDisplay())

package/src/engine/graphics/ecs/camera/pp/PerfectPanner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PerfectPanner.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/pp/PerfectPanner.js"],"names":[],"mappings":"AAWA;IA4CI;;;OAGG;IACH,wBAEC;IAVD,qBAEC;IAUD;;OAEG;IACH,2BAEC;IAwBD;;;OAGG;IACH,wBAFW,OAAO,QA4BjB;IAED,kCAuCC;IAED,YAEC;;CAEJ;oBAzKmB,qCAAqC;oBAKrC,qCAAqC"}
+{"version":3,"file":"PerfectPanner.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/pp/PerfectPanner.js"],"names":[],"mappings":"AAYA;IA4CI;;;OAGG;IACH,wBAEC;IAVD,qBAEC;IAUD;;OAEG;IACH,2BAEC;IAwBD;;;OAGG;IACH,wBAFW,OAAO,QA4BjB;IAED,kCAuCC;IAED,YAEC;;CAEJ;oBA1KmB,qCAAqC;oBAKrC,qCAAqC"}

package/src/engine/graphics/ecs/camera/pp/PerfectPanner.js

@@ -4,7 +4,8 @@ import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { make_ray_from_viewport_position } from "../../../make_ray_from_viewport_position.js";
 import { camera_find_active } from "../camera_find_active.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
-import { Transform } from "../../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../../ecs/transform/Transform64.js";
+import { t64_read_translation } from "../../../../ecs/transform/t64_read_translation.js";
 
 const NEAR_PLANE_INDEX = 5;
 const FAR_PLANE_INDEX = 4;
@@ -38,7 +39,7 @@ export class PerfectPanner {
     #camera = null;
     /**
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     #camera_transform = null;
 
@@ -138,7 +139,7 @@ export class PerfectPanner {
         // bind camera
         const camera = camera_find_active(ecd);
         this.#camera = camera.component;
-        this.#camera_transform = ecd.getComponent(camera.entity, Transform);
+        this.#camera_transform = ecd.getComponent(camera.entity, Transform64);
 
 
         this.#projection_viewport_onto_plane(this.#grab_near_projection, screen_position.x, screen_position.y, NEAR_PLANE_INDEX);
@@ -158,7 +159,7 @@ export class PerfectPanner {
             this.#grab_world_reference.copy(hit.position);
         }
 
-        this.#grab_eye_position.copy(this.#camera_transform.position);
+        t64_read_translation(this.#grab_eye_position, this.#camera_transform);
 
         this.#translation.set(0, 0, 0);
     }

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopDownCameraController.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH,iDALW,MAAM,kBACN,MAAM,SACN,uBAAuB,UACvB,uBAAuB,QAiBjC;AAED;;;;;;;GAOG;AACH,+CAHW,UAAU,cACV,uBAAuB,QAIjC;;AAkED;IA2JI,iDAMC;IAxJD,0BAKC;IAbD,gBAAuB;IACvB,cAAU;IACV,YAAQ;IACR,aAAS;IACT,iBAAa;IACb,oBAAgB;IAChB,oBAAkB;IASlB;;;;;;;;;OASG;IACH,yBAJW,OAAO,UACP,OAAO,OACP,OAAO,QA4BjB;IAED;;;;OAIG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAWnB;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAYjC;IAED;;;OAGG;IACH,SAFa,uBAAuB,CAQnC;IAED;;;;;OAKG;IACH,QAJW,uBAAuB,KACvB,uBAAuB,KACvB,MAAM,QAahB;IAED;;;;;;;;;;;;MAYC;IAED;;;;;;;;aAsBC;CASJ;;;;;;uBAxRsB,wCAAwC;oBAC3C,qCAAqC;AAqEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iDAPW,uBAAuB,sBACvB,MAAM,OAEN,MAAM,eACN,OAAO,QA2BjB"}
+{"version":3,"file":"TopDownCameraController.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,iDALW,MAAM,kBACN,MAAM,SACN,uBAAuB,UACvB,uBAAuB,QAiBjC;AAED;;;;;;;GAOG;AACH,+CAHW,UAAU,cACV,uBAAuB,QAIjC;;AAkED;IA+JI,iDAMC;IA5JD,0BAKC;IAbD,gBAAuB;IACvB,cAAU;IACV,YAAQ;IACR,aAAS;IACT,iBAAa;IACb,oBAAgB;IAChB,oBAAkB;IASlB;;;;;;;;;OASG;IACH,yBAJW,OAAO,UACP,OAAO,OACP,OAAO,QAgCjB;IAED;;;;OAIG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAWnB;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAYjC;IAED;;;OAGG;IACH,SAFa,uBAAuB,CAQnC;IAED;;;;;OAKG;IACH,QAJW,uBAAuB,KACvB,uBAAuB,KACvB,MAAM,QAahB;IAED;;;;;;;;;;;;MAYC;IAED;;;;;;;;aAsBC;CASJ;;;;;;uBA7RsB,wCAAwC;oBAC3C,qCAAqC;AAsEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iDAPW,uBAAuB,sBACvB,MAAM,OAEN,MAAM,eACN,OAAO,QA2BjB"}

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -9,6 +9,7 @@ import Vector3 from '../../../../../core/geom/Vector3.js';
 import { lerp } from "../../../../../core/math/lerp.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { sign_not_zero } from "../../../../../core/math/sign_not_zero.js";
+import { v3_distance } from "../../../../../core/geom/vec3/v3_distance.js";
 
 const m4 = [];
 const angles = [];
@@ -150,8 +151,12 @@ class TopDownCameraController {
      */
     setFromEyeAndTarget(eye, target, up = Vector3.up) {
 
-        v3_forward.copy(target);
-        v3_forward.sub(eye);
+        // index reads accept a Vector3 or a transform's translation view alike
+        v3_forward.set(
+            target[0] - eye[0],
+            target[1] - eye[1],
+            target[2] - eye[2]
+        );
 
         q_look.lookRotation(v3_forward, up);
 
@@ -168,7 +173,7 @@ class TopDownCameraController {
         this.yaw = angles[1];
         this.roll = angles[0];
 
-        this.distance = eye.distanceTo(target);
+        this.distance = v3_distance(eye[0], eye[1], eye[2], target[0], target[1], target[2]);
 
         // ensure we can maintain this distance
         this.distanceMax = max2(this.distance, this.distanceMax);

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.d.ts

@@ -1,24 +1,24 @@
 /**
  *
  * @param {TopDownCameraController} control
- * @param {Transform} result
+ * @param {Transform64} result
  */
-export function computeTopDownTransform(control: TopDownCameraController, result: Transform): void;
+export function computeTopDownTransform(control: TopDownCameraController, result: Transform64): void;
 /**
  *
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {TopDownCameraController} controller
  * @param {number} distance
  */
-export function setCameraControllerFromTransform(transform: Transform, controller: TopDownCameraController, distance?: number): void;
+export function setCameraControllerFromTransform(transform: Transform64, controller: TopDownCameraController, distance?: number): void;
 export default TopDownCameraControllerSystem;
 import TopDownCameraController from './TopDownCameraController.js';
-import { Transform } from '../../../../ecs/transform/Transform.js';
+import { Transform64 } from '../../../../ecs/transform/Transform64.js';
 declare class TopDownCameraControllerSystem extends System<any> {
     constructor();
     enabled: ObservedValue;
     dependencies: (typeof TopDownCameraController)[];
-    components_used: ResourceAccessSpecification<typeof Transform>[];
+    components_used: ResourceAccessSpecification<typeof Transform64>[];
     /**
      *
      * @param {TopDownCameraController} ctrl

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopDownCameraControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js"],"names":[],"mappings":"AAqDA;;;;GAIG;AACH,iDAHW,uBAAuB,UACvB,SAAS,QAsBnB;AAED;;;;;GAKG;AACH,4DAJW,SAAS,cACT,uBAAuB,aACvB,MAAM,QAQhB;;oCAnF+D,8BAA8B;0BAHpE,wCAAwC;AAQlE;;IACI,uBAAkC;IAClC,iDAAyC;IACzC,iEAEE;IAEF;;;;;OAKG;IACH,8BAQC;IAED,6BAaC;CACJ;uBA9CsB,2BAA2B;0BAHxB,4CAA4C;4CAE1B,0DAA0D"}
+{"version":3,"file":"TopDownCameraControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js"],"names":[],"mappings":"AAwDA;;;;GAIG;AACH,iDAHW,uBAAuB,UACvB,WAAW,QA0BrB;AAED;;;;;GAKG;AACH,4DAJW,WAAW,cACX,uBAAuB,aACvB,MAAM,QAahB;;oCA/F+D,8BAA8B;4BAHlE,0CAA0C;AAWtE;;IACI,uBAAkC;IAClC,iDAAyC;IACzC,mEAEE;IAEF;;;;;OAKG;IACH,8BAQC;IAED,6BAaC;CACJ;uBAjDsB,2BAA2B;0BAHxB,4CAA4C;4CAE1B,0DAA0D"}

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js

@@ -4,19 +4,22 @@ import ObservedValue from "../../../../../core/model/ObservedValue.js";
 import { ResourceAccessKind } from "../../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../../core/model/ResourceAccessSpecification.js";
 import { System } from '../../../../ecs/System.js';
-import { Transform } from '../../../../ecs/transform/Transform.js';
+import { Transform64 } from '../../../../ecs/transform/Transform64.js';
 
 
 import TopDownCameraController, { top_down_view_rotation } from './TopDownCameraController.js';
+import Quaternion from "../../../../../core/geom/Quaternion.js";
+import { v3_quaternion_apply } from "../../../../../core/geom/vec3/v3_quaternion_apply.js";
 
 
 const v3_scratch = new Vector3();
+const q_scratch = new Quaternion();
 
 class TopDownCameraControllerSystem extends System {
     enabled = new ObservedValue(true);
     dependencies = [TopDownCameraController];
     components_used = [
-        ResourceAccessSpecification.from(Transform,ResourceAccessKind.Write)
+        ResourceAccessSpecification.from(Transform64,ResourceAccessKind.Write)
     ];
 
     /**
@@ -26,7 +29,7 @@ class TopDownCameraControllerSystem extends System {
      * @private
      */
     __visit_camera_entity(ctrl, entity){
-        const transform = this.entityManager.dataset.getComponent(entity,Transform);
+        const transform = this.entityManager.dataset.getComponent(entity,Transform64);
 
         if(transform === undefined){
             return;
@@ -54,42 +57,51 @@ class TopDownCameraControllerSystem extends System {
 /**
  *
  * @param {TopDownCameraController} control
- * @param {Transform} result
+ * @param {Transform64} result
  */
 export function computeTopDownTransform(control, result) {
 
-    const rotation = result.rotation;
-
     //clamp the distance
     const distance = clamp(control.distance, control.distanceMin, control.distanceMax);
     const target = control.target;
 
-    // compute rotation
-    top_down_view_rotation(rotation, control);
+    // compute rotation. The transform holds its rotation as four numbers rather than a Quaternion,
+    // so the euler composition runs in a scratch and lands in the transform afterwards.
+    top_down_view_rotation(q_scratch, control);
+
+    result.setRotation(q_scratch.x, q_scratch.y, q_scratch.z, q_scratch.w);
 
     // compute camera position
     v3_scratch.copy(Vector3.forward);
-    v3_scratch.applyQuaternion(rotation);
+    v3_scratch.applyQuaternion(q_scratch);
 
     v3_scratch.multiplyScalar(-distance);
 
     v3_scratch.add(target);
 
-    result.position.copy(v3_scratch);
+    result.setTranslation(v3_scratch.x, v3_scratch.y, v3_scratch.z);
+
+    // the rotation moved, so the matrix owes an update
+    result.updateMatrix();
 }
 
 /**
  *
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {TopDownCameraController} controller
  * @param {number} distance
  */
 export function setCameraControllerFromTransform(transform, controller, distance = 20) {
     const v_f = Vector3.forward.clone();
     v_f.multiplyScalar(distance);
-    v_f.applyQuaternion(transform.rotation);
 
-    controller.setFromEyeAndTarget(transform.position,v_f);
+    v3_quaternion_apply(
+        v_f, 0,
+        v_f.x, v_f.y, v_f.z,
+        transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
+    );
+
+    controller.setFromEyeAndTarget(transform.translation, v_f);
 }
 
 export default TopDownCameraControllerSystem;

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraLanderSystem.js

@@ -63,7 +63,7 @@ function land(lander, controller, terrain, samplerCache) {
     const target = controller.target;
 
 
-    terrain.mapPointWorld2Grid(target, v2_scratch);
+    terrain.mapPointWorld2Grid(target.x, target.z, v2_scratch);
 
     v2_scratch.divide(terrain.size);
 

package/src/engine/graphics/ecs/mesh/setMesh.js

@@ -1,4 +1,4 @@
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { MeshEvents } from "./MeshEvents.js";
 
 /**
@@ -40,7 +40,7 @@ export function setMesh(dataset, entity, component, mesh) {
 
     component.mesh = mesh;
 
-    const transform = dataset.getComponent(entity, Transform);
+    const transform = dataset.getComponent(entity, Transform64);
 
     if (transform !== undefined) {
         // transform component found, apply transform

package/src/engine/graphics/ecs/path/entity/EntityPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityPath.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/path/entity/EntityPath.js"],"names":[],"mappings":"AAqBA;IACI;;;OAGG;IACH,uBAAa;IAEb;;;OAGG;IACH,WAAY;IAEZ;;;OAGG;IACH,SAFU,gBAAgB,EAAE,CAEf;IAEb;;;OAGG;IACH,0BAKC;IAED;;;OAGG;IACH,gBAEC;IAED;;OAEG;IACH,uCAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,uBAYC;IAGD;;;;OAIG;IACH,0BAiCC;IAED,8BAiBC;IAED,cAmCC;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACG,gBAAgB,+BAenC;IAED;;;;;OAKG;IACH,2BAJW,MAAM,mBACG,gBAAgB,+BAiBnC;CACJ;iCAvOgC,uBAAuB"}
+{"version":3,"file":"EntityPath.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/path/entity/EntityPath.js"],"names":[],"mappings":"AA6BA;IACI;;;OAGG;IACH,uBAAa;IAEb;;;OAGG;IACH,WAAY;IAEZ;;;OAGG;IACH,SAFU,gBAAgB,EAAE,CAEf;IAEb;;;OAGG;IACH,0BAKC;IAED;;;OAGG;IACH,gBAEC;IAED;;OAEG;IACH,uCAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,uBAYC;IAGD;;;;OAIG;IACH,0BAuCC;IAED,8BAiBC;IAED,cAmCC;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACG,gBAAgB,+BAenC;IAED;;;;;OAKG;IACH,2BAJW,MAAM,mBACG,gBAAgB,+BAiBnC;CACJ;iCArPgC,uBAAuB"}