@phalanx-engine/physics 0.1.0 → 0.1.2

package/README.md

@@ -125,7 +125,7 @@ import {
   TRANSFORM_COMPONENT_TYPE,
   INTERPOLATION_COMPONENT_TYPE,
 } from '@phalanx-engine/physics';
-import { FP, FPVector3 } from '@phalanx-engine/math';
+import { FP, FPVector3, FPQuaternion } from '@phalanx-engine/math';
 
 // Register canonical component type symbols from phalanx-physics
 export const ComponentType = createComponentTypeRegistry({
@@ -144,7 +144,11 @@ class MovementSystem extends GameSystem {
 class RenderSystem extends GameSystem {
   public override update(_dt: number): void {
     const sample = this.physics?.getInterpolatedTransform(entityId);
-    if (sample) mesh.position.set(sample.position.x, sample.position.y, sample.position.z);
+    if (sample) {
+      mesh.position.set(sample.position.x, sample.position.y, sample.position.z);
+      // sample.rotation is a float quaternion { x, y, z, w } — apply it as-is.
+      mesh.quaternion.set(sample.rotation.x, sample.rotation.y, sample.rotation.z, sample.rotation.w);
+    }
   }
 }
 const movementSystem = new MovementSystem();
@@ -176,8 +180,9 @@ world.start();
 // 4. Add transform, interpolation, and physics body to entities
 declare const entity: { id: number; addComponent(c: unknown): void };
 const fpPosition = FPVector3.FromFloat(0, 0, 0);
-entity.addComponent(new TransformComponent(entity.id, fpPosition));
-entity.addComponent(new InterpolationComponent(fpPosition));
+const fpRotation = FPQuaternion.Identity();
+entity.addComponent(new TransformComponent(entity.id, fpPosition, fpRotation));
+entity.addComponent(new InterpolationComponent(fpPosition, fpRotation));
 entity.addComponent(new PhysicsBodyComponent(entity.id, { radius: FP.FromFloat(1.0) }));
 world.entityManager.addEntity(entity as any);
 
@@ -282,7 +287,7 @@ class PhysicsWorld {
 
 - **`getSystems()`** — Returns both `physicsSystem` (register as tick system) and `interpolationSystem` (register as frame system).
 - **`getEntityPosition(entityId)`** — Fixed-point position for gameplay queries (e.g. ability targeting).
-- **`getInterpolatedTransform(entityId)`** — Interpolated float position/rotation for rendering, populated after `InterpolationSystem` runs.
+- **`getInterpolatedTransform(entityId)`** — Interpolated float transform for rendering, populated after `InterpolationSystem` runs. Returns an `InterpolatedTransformSample` with `position: { x, y, z }` and `rotation: { x, y, z, w }` — rotation is a float quaternion (slerped between tick samples), apply it directly to a mesh quaternion.
 
 - **`applyImpulse(entityId, vx, vz)`** — Set body velocity (replaces, does not accumulate). Re-enables previously ejected bodies.
 - **`isSettled(threshold?)`** — Pure query: `true` when all non-static, non-ignored bodies are below velocity threshold (default from config, falling back to `FP.FromFloat(0.01)`).
@@ -314,15 +319,18 @@ class TransformComponent extends SoAComponent<typeof TransformSoASchema.definiti
   static readonly soaSchema: typeof TransformSoASchema;
   readonly type: symbol; // TRANSFORM_COMPONENT_TYPE
 
-  constructor(entityId: number, initialPosition?: FPVector3, initialRotation?: FPVector3);
+  constructor(entityId: number, initialPosition?: FPVector3, initialRotation?: FPQuaternion);
 
-  fpPosition: FPVector3;   // get/set — authoritative fixed-point position
-  fpRotation: FPVector3;   // get/set — authoritative fixed-point rotation (radians)
-  fpRotationY: FixedPoint; // get/set — convenience for Y-axis rotation
+  fpPosition: FPVector3;        // get/set — authoritative fixed-point position
+  fpRotation: FPQuaternion;     // get/set — authoritative rotation quaternion
+  fpRotationEuler: FPVector3;   // get/set — computed Euler view (radians, XYZ order)
+  fpRotationY: FixedPoint;      // get/set — convenience Y-yaw (radians)
 }
 ```
 
-`TransformSoASchema` fields: `fpPositionX/Y/Z`, `fpRotationX/Y/Z` (all `i64`).
+Rotation is authoritatively a quaternion (`fpRotation`). `fpRotationEuler` (XYZ Euler radians) and `fpRotationY` (yaw) are computed views over it — recomputed on each access, mirroring Unity's `Transform.rotation` / `Transform.eulerAngles`. Setting `fpRotationEuler` calls `FPQuaternion.FromEulerXYZ`; setting `fpRotationY` builds a yaw rotation around `FPVector3.Up`.
+
+`TransformSoASchema` fields: `fpPositionX/Y/Z`, `fpRotationX/Y/Z/W` (all `i64`). Rotation defaults to the identity quaternion (`w = 1`).
 
 ### `InterpolationComponent`
 
@@ -330,10 +338,10 @@ class TransformComponent extends SoAComponent<typeof TransformSoASchema.definiti
 class InterpolationComponent implements IComponent {
   readonly type: symbol; // INTERPOLATION_COMPONENT_TYPE
 
-  constructor(initialPosition?: FPVector3, initialRotation?: FPVector3);
+  constructor(initialPosition?: FPVector3, initialRotation?: FPQuaternion);
 
   snapshot(): void;  // copy current → previous (called by InterpolationSystem before tick)
-  capture(fpPosition: FPVector3, fpRotation: FPVector3): void; // capture authoritative state after tick
+  capture(fpPosition: FPVector3, fpRotation: FPQuaternion): void; // capture authoritative state after tick
 }
 ```
 

package/dist/components/InterpolationComponent.d.ts

@@ -1,15 +1,16 @@
 import type { IComponent } from '@phalanx-engine/ecs';
-import type { FPVector3 as FPVector3Type } from '@phalanx-engine/math';
+import type { FPVector3 as FPVector3Type, FPQuaternion as FPQuaternionType } from '@phalanx-engine/math';
 export declare const INTERPOLATION_COMPONENT_TYPE: symbol;
 export declare class InterpolationComponent implements IComponent {
     readonly type: symbol;
     readonly previousFpPosition: FPVector3Type;
     readonly currentFpPosition: FPVector3Type;
-    readonly previousFpRotation: FPVector3Type;
-    readonly currentFpRotation: FPVector3Type;
-    constructor(initialPosition?: FPVector3Type, initialRotation?: FPVector3Type);
+    readonly previousFpRotation: FPQuaternionType;
+    readonly currentFpRotation: FPQuaternionType;
+    constructor(initialPosition?: FPVector3Type, initialRotation?: FPQuaternionType);
     snapshot(): void;
-    capture(fpPosition: FPVector3Type, fpRotation: FPVector3Type): void;
+    capture(fpPosition: FPVector3Type, fpRotation: FPQuaternionType): void;
     private copyFpVector3;
+    private copyFpQuaternion;
 }
 //# sourceMappingURL=InterpolationComponent.d.ts.map

package/dist/components/InterpolationComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationComponent.d.ts","sourceRoot":"","sources":["../../src/components/InterpolationComponent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAMvE,eAAO,MAAM,4BAA4B,EAAE,MAAgC,CAAC;AAS5E,qBAAa,sBAAuB,YAAW,UAAU;IACvD,SAAgB,IAAI,SAAgC;IAEpD,SAAgB,kBAAkB,EAAE,aAAa,CAAoC;IACrF,SAAgB,iBAAiB,EAAE,aAAa,CAAoC;IACpF,SAAgB,kBAAkB,EAAE,aAAa,CAAoC;IACrF,SAAgB,iBAAiB,EAAE,aAAa,CAAoC;gBAExE,eAAe,CAAC,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE,aAAa;IAYrE,QAAQ,IAAI,IAAI;IAMhB,OAAO,CAAC,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,GAAG,IAAI;IAK1E,OAAO,CAAC,aAAa;CAKtB"}
+{"version":3,"file":"InterpolationComponent.d.ts","sourceRoot":"","sources":["../../src/components/InterpolationComponent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,KAAK,EACV,SAAS,IAAI,aAAa,EAC1B,YAAY,IAAI,gBAAgB,EACjC,MAAM,sBAAsB,CAAC;AAM9B,eAAO,MAAM,4BAA4B,EAAE,MAAgC,CAAC;AAU5E,qBAAa,sBAAuB,YAAW,UAAU;IACvD,SAAgB,IAAI,SAAgC;IAEpD,SAAgB,kBAAkB,EAAE,aAAa,CAAoC;IACrF,SAAgB,iBAAiB,EAAE,aAAa,CAAoC;IACpF,SAAgB,kBAAkB,EAAE,gBAAgB,CAA8C;IAClG,SAAgB,iBAAiB,EAAE,gBAAgB,CAA8C;gBAErF,eAAe,CAAC,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE,gBAAgB;IAYxE,QAAQ,IAAI,IAAI;IAMhB,OAAO,CAAC,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAK7E,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,gBAAgB;CAMzB"}

package/dist/components/InterpolationComponent.js

@@ -4,29 +4,35 @@ export class InterpolationComponent {
     type = INTERPOLATION_COMPONENT_TYPE;
     previousFpPosition = { x: FP._0, y: FP._0, z: FP._0 };
     currentFpPosition = { x: FP._0, y: FP._0, z: FP._0 };
-    previousFpRotation = { x: FP._0, y: FP._0, z: FP._0 };
-    currentFpRotation = { x: FP._0, y: FP._0, z: FP._0 };
+    previousFpRotation = { x: FP._0, y: FP._0, z: FP._0, w: FP._1 };
+    currentFpRotation = { x: FP._0, y: FP._0, z: FP._0, w: FP._1 };
     constructor(initialPosition, initialRotation) {
         if (initialPosition) {
             this.copyFpVector3(this.previousFpPosition, initialPosition);
             this.copyFpVector3(this.currentFpPosition, initialPosition);
         }
         if (initialRotation) {
-            this.copyFpVector3(this.previousFpRotation, initialRotation);
-            this.copyFpVector3(this.currentFpRotation, initialRotation);
+            this.copyFpQuaternion(this.previousFpRotation, initialRotation);
+            this.copyFpQuaternion(this.currentFpRotation, initialRotation);
         }
     }
     snapshot() {
         this.copyFpVector3(this.previousFpPosition, this.currentFpPosition);
-        this.copyFpVector3(this.previousFpRotation, this.currentFpRotation);
+        this.copyFpQuaternion(this.previousFpRotation, this.currentFpRotation);
     }
     capture(fpPosition, fpRotation) {
         this.copyFpVector3(this.currentFpPosition, fpPosition);
-        this.copyFpVector3(this.currentFpRotation, fpRotation);
+        this.copyFpQuaternion(this.currentFpRotation, fpRotation);
     }
     copyFpVector3(target, source) {
         target.x = source.x;
         target.y = source.y;
         target.z = source.z;
     }
+    copyFpQuaternion(target, source) {
+        target.x = source.x;
+        target.y = source.y;
+        target.z = source.z;
+        target.w = source.w;
+    }
 }

package/dist/components/TransformComponent.d.ts

@@ -1,5 +1,5 @@
 import { SoAComponent } from '@phalanx-engine/ecs';
-import { type FixedPoint, type FPVector3 as FPVector3Type } from '@phalanx-engine/math';
+import { type FixedPoint, type FPVector3 as FPVector3Type, type FPQuaternion as FPQuaternionType } from '@phalanx-engine/math';
 export declare const TransformSoASchema: import("@phalanx-engine/ecs").SoASchema<{
     fpPositionX: "i64";
     fpPositionY: "i64";
@@ -7,6 +7,7 @@ export declare const TransformSoASchema: import("@phalanx-engine/ecs").SoASchema
     fpRotationX: "i64";
     fpRotationY: "i64";
     fpRotationZ: "i64";
+    fpRotationW: "i64";
 }>;
 export declare const TRANSFORM_COMPONENT_TYPE: symbol;
 export declare class TransformComponent extends SoAComponent<typeof TransformSoASchema.definition> {
@@ -18,14 +19,17 @@ export declare class TransformComponent extends SoAComponent<typeof TransformSoA
         fpRotationX: "i64";
         fpRotationY: "i64";
         fpRotationZ: "i64";
+        fpRotationW: "i64";
     }>;
     private readonly _fpPosition;
     private readonly _fpRotation;
-    constructor(entityId: number, initialPosition?: FPVector3Type, initialRotation?: FPVector3Type);
+    constructor(entityId: number, initialPosition?: FPVector3Type, initialRotation?: FPQuaternionType);
     get fpPosition(): FPVector3Type;
     set fpPosition(value: FPVector3Type);
-    get fpRotation(): FPVector3Type;
-    set fpRotation(value: FPVector3Type);
+    get fpRotation(): FPQuaternionType;
+    set fpRotation(value: FPQuaternionType);
+    get fpRotationEuler(): FPVector3Type;
+    set fpRotationEuler(value: FPVector3Type);
     get fpRotationY(): FixedPoint;
     set fpRotationY(value: FixedPoint);
 }

package/dist/components/TransformComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformComponent.d.ts","sourceRoot":"","sources":["../../src/components/TransformComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAmB,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAiB,KAAK,UAAU,EAAE,KAAK,SAAS,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAQvG,eAAO,MAAM,kBAAkB;;;;;;;EAU9B,CAAC;AAMF,eAAO,MAAM,wBAAwB,EAAE,MAA4B,CAAC;AAapE,qBAAa,kBAAmB,SAAQ,YAAY,CAAC,OAAO,kBAAkB,CAAC,UAAU,CAAC;IACxF,SAAgB,IAAI,SAA4B;IAChD,gBAAuB,SAAS;;;;;;;OAAsB;IAEtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmD;IAC/E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmD;gBAG7E,QAAQ,EAAE,MAAM,EAChB,eAAe,CAAC,EAAE,aAAa,EAC/B,eAAe,CAAC,EAAE,aAAa;IAejC,IAAW,UAAU,IAAI,aAAa,CASrC;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,aAAa,EAQzC;IAED,IAAW,UAAU,IAAI,aAAa,CAQrC;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,aAAa,EAOzC;IAED,IAAW,WAAW,IAAI,UAAU,CAInC;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,UAAU,EAIvC;CACF"}
+{"version":3,"file":"TransformComponent.d.ts","sourceRoot":"","sources":["../../src/components/TransformComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAmB,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,SAAS,IAAI,aAAa,EAC/B,KAAK,YAAY,IAAI,gBAAgB,EACtC,MAAM,sBAAsB,CAAC;AAU9B,eAAO,MAAM,kBAAkB;;;;;;;;EAW9B,CAAC;AAMF,eAAO,MAAM,wBAAwB,EAAE,MAA4B,CAAC;AAiBpE,qBAAa,kBAAmB,SAAQ,YAAY,CAAC,OAAO,kBAAkB,CAAC,UAAU,CAAC;IACxF,SAAgB,IAAI,SAA4B;IAChD,gBAAuB,SAAS;;;;;;;;OAAsB;IAEtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmD;IAC/E,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgE;gBAG1F,QAAQ,EAAE,MAAM,EAChB,eAAe,CAAC,EAAE,aAAa,EAC/B,eAAe,CAAC,EAAE,gBAAgB;IAgBpC,IAAW,UAAU,IAAI,aAAa,CASrC;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,aAAa,EAQzC;IAGD,IAAW,UAAU,IAAI,gBAAgB,CASxC;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,gBAAgB,EAQ5C;IAOD,IAAW,eAAe,IAAI,aAAa,CAE1C;IAED,IAAW,eAAe,CAAC,KAAK,EAAE,aAAa,EAE9C;IAGD,IAAW,WAAW,IAAI,UAAU,CAMnC;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,UAAU,EAEvC;CACF"}

package/dist/components/TransformComponent.js

@@ -1,5 +1,5 @@
 import { SoAComponent, defineSoASchema } from '@phalanx-engine/ecs';
-import { FP, FPVector3 } from '@phalanx-engine/math';
+import { FP, FPVector3, FPQuaternion, } from '@phalanx-engine/math';
 export const TransformSoASchema = defineSoASchema({
     fpPositionX: 'i64',
     fpPositionY: 'i64',
@@ -7,16 +7,17 @@ export const TransformSoASchema = defineSoASchema({
     fpRotationX: 'i64',
     fpRotationY: 'i64',
     fpRotationZ: 'i64',
+    fpRotationW: 'i64',
 }, 'Transform');
 export const TRANSFORM_COMPONENT_TYPE = Symbol('Transform');
 export class TransformComponent extends SoAComponent {
     type = TRANSFORM_COMPONENT_TYPE;
     static soaSchema = TransformSoASchema;
     _fpPosition = { x: FP._0, y: FP._0, z: FP._0 };
-    _fpRotation = { x: FP._0, y: FP._0, z: FP._0 };
+    _fpRotation = { x: FP._0, y: FP._0, z: FP._0, w: FP._1 };
     constructor(entityId, initialPosition, initialRotation) {
         const position = initialPosition ?? FPVector3.Zero;
-        const rotation = initialRotation ?? FPVector3.Zero;
+        const rotation = initialRotation ?? FPQuaternion.Identity();
         super(TransformSoASchema, entityId, {
             fpPositionX: FP.ToRaw(position.x),
             fpPositionY: FP.ToRaw(position.y),
@@ -24,6 +25,7 @@ export class TransformComponent extends SoAComponent {
             fpRotationX: FP.ToRaw(rotation.x),
             fpRotationY: FP.ToRaw(rotation.y),
             fpRotationZ: FP.ToRaw(rotation.z),
+            fpRotationW: FP.ToRaw(rotation.w),
         });
     }
     get fpPosition() {
@@ -50,6 +52,7 @@ export class TransformComponent extends SoAComponent {
         this._fpRotation.x = FP.FromRaw(this.store.arrays.fpRotationX[idx]);
         this._fpRotation.y = FP.FromRaw(this.store.arrays.fpRotationY[idx]);
         this._fpRotation.z = FP.FromRaw(this.store.arrays.fpRotationZ[idx]);
+        this._fpRotation.w = FP.FromRaw(this.store.arrays.fpRotationW[idx]);
         return this._fpRotation;
     }
     set fpRotation(value) {
@@ -59,17 +62,22 @@ export class TransformComponent extends SoAComponent {
         this.store.arrays.fpRotationX[idx] = FP.ToRaw(value.x);
         this.store.arrays.fpRotationY[idx] = FP.ToRaw(value.y);
         this.store.arrays.fpRotationZ[idx] = FP.ToRaw(value.z);
+        this.store.arrays.fpRotationW[idx] = FP.ToRaw(value.w);
+    }
+    get fpRotationEuler() {
+        return FPQuaternion.ToEulerXYZ(this.fpRotation);
+    }
+    set fpRotationEuler(value) {
+        this.fpRotation = FPQuaternion.FromEulerXYZ(value);
     }
     get fpRotationY() {
-        const idx = this.getIndex();
-        if (idx === -1)
-            return FP._0;
-        return FP.FromRaw(this.store.arrays.fpRotationY[idx]);
+        const q = this.fpRotation;
+        const two = FP.FromInt(2);
+        const sinY = FP.Mul(two, FP.Add(FP.Mul(q.w, q.y), FP.Mul(q.x, q.z)));
+        const cosY = FP.Sub(FP._1, FP.Mul(two, FP.Add(FP.Mul(q.y, q.y), FP.Mul(q.z, q.z))));
+        return FP.Atan2(sinY, cosY);
     }
     set fpRotationY(value) {
-        const idx = this.getIndex();
-        if (idx === -1)
-            return;
-        this.store.arrays.fpRotationY[idx] = FP.ToRaw(value);
+        this.fpRotation = FPQuaternion.FromYaw(value);
     }
 }

package/dist/systems/InterpolationSystem.d.ts

@@ -9,6 +9,7 @@ export interface InterpolatedTransformSample {
         x: number;
         y: number;
         z: number;
+        w: number;
     };
 }
 export declare class InterpolationSystem extends GameSystem implements IBeforeTick, IAfterTick, IBeforeFrame {
@@ -23,6 +24,7 @@ export declare class InterpolationSystem extends GameSystem implements IBeforeTi
     capture(): void;
     interpolate(alpha: number): void;
     getInterpolatedTransform(entityId: number): InterpolatedTransformSample | undefined;
-    private readFpVector3;
+    private readFpPosition;
+    private readFpRotation;
 }
 //# sourceMappingURL=InterpolationSystem.d.ts.map

package/dist/systems/InterpolationSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../src/systems/InterpolationSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,WAAW,EAEhB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAQ7B,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C;AAoBD,qBAAa,mBACX,SAAQ,UACR,YAAW,WAAW,EAAE,UAAU,EAAE,YAAY;IAEhD,OAAO,CAAC,cAAc,CAA2D;IACjF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkD;IAEtF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IAEtC,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAK3C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI;IAIzD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI9B,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAI7C,QAAQ,IAAI,IAAI;IAOhB,OAAO,IAAI,IAAI;IA6Cf,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAiChC,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,2BAA2B,GAAG,SAAS;IAI1F,OAAO,CAAC,aAAa;CAatB"}
+{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../src/systems/InterpolationSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,WAAW,EAEhB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAc7B,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAE9C,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1D;AAWD,qBAAa,mBACX,SAAQ,UACR,YAAW,WAAW,EAAE,UAAU,EAAE,YAAY;IAEhD,OAAO,CAAC,cAAc,CAA2D;IACjF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkD;IAEtF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IAEtC,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAK3C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI;IAIzD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI9B,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAI7C,QAAQ,IAAI,IAAI;IAOhB,OAAO,IAAI,IAAI;IAmCf,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAkChC,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,2BAA2B,GAAG,SAAS;IAI1F,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,cAAc;CASvB"}

package/dist/systems/InterpolationSystem.js

@@ -1,16 +1,7 @@
 import { GameSystem, } from '@phalanx-engine/ecs';
-import { FP, FPVector3 } from '@phalanx-engine/math';
+import { FP, FPVector3, FPQuaternion, } from '@phalanx-engine/math';
 import { INTERPOLATION_COMPONENT_TYPE, } from '../components';
 import { TRANSFORM_COMPONENT_TYPE, TransformSoASchema } from '../components';
-function lerpAngle(from, to, t) {
-    const clamped = Math.max(0, Math.min(1, t));
-    let delta = to - from;
-    if (delta > Math.PI)
-        delta -= 2 * Math.PI;
-    if (delta < -Math.PI)
-        delta += 2 * Math.PI;
-    return from + delta * clamped;
-}
 function lerpScalar(from, to, t) {
     const clamped = Math.max(0, Math.min(1, t));
     return from + (to - from) * clamped;
@@ -47,8 +38,8 @@ export class InterpolationSystem extends GameSystem {
             const transformIndex = this.transformStore.indexOf(entity.id);
             if (!interpolation || transformIndex === -1)
                 continue;
-            const fpPosition = this.readFpVector3(transformIndex, 'fpPositionX', 'fpPositionY', 'fpPositionZ');
-            const fpRotation = this.readFpVector3(transformIndex, 'fpRotationX', 'fpRotationY', 'fpRotationZ');
+            const fpPosition = this.readFpPosition(transformIndex);
+            const fpRotation = this.readFpRotation(transformIndex);
             if (!this.capturedEntities.has(entity.id)) {
                 interpolation.capture(fpPosition, fpRotation);
                 interpolation.snapshot();
@@ -66,6 +57,7 @@ export class InterpolationSystem extends GameSystem {
     }
     interpolate(alpha) {
         const clampedAlpha = Math.max(0, Math.min(1, alpha));
+        const fpAlpha = FP.FromFloat(clampedAlpha);
         this.interpolatedSamples.clear();
         const entities = this.entityManager.queryEntities(INTERPOLATION_COMPONENT_TYPE, TRANSFORM_COMPONENT_TYPE);
         for (const entity of entities) {
@@ -74,31 +66,35 @@ export class InterpolationSystem extends GameSystem {
                 continue;
             const previousPosition = FPVector3.ToFloat(interpolation.previousFpPosition);
             const currentPosition = FPVector3.ToFloat(interpolation.currentFpPosition);
-            const previousRotation = FPVector3.ToFloat(interpolation.previousFpRotation);
-            const currentRotation = FPVector3.ToFloat(interpolation.currentFpRotation);
+            const interpolatedRotation = FPQuaternion.Slerp(interpolation.previousFpRotation, interpolation.currentFpRotation, fpAlpha);
             this.interpolatedSamples.set(entity.id, {
                 position: {
                     x: lerpScalar(previousPosition.x, currentPosition.x, clampedAlpha),
                     y: lerpScalar(previousPosition.y, currentPosition.y, clampedAlpha),
                     z: lerpScalar(previousPosition.z, currentPosition.z, clampedAlpha),
                 },
-                rotation: {
-                    x: lerpAngle(previousRotation.x, currentRotation.x, clampedAlpha),
-                    y: lerpAngle(previousRotation.y, currentRotation.y, clampedAlpha),
-                    z: lerpAngle(previousRotation.z, currentRotation.z, clampedAlpha),
-                },
+                rotation: FPQuaternion.ToFloat(interpolatedRotation),
             });
         }
     }
     getInterpolatedTransform(entityId) {
         return this.interpolatedSamples.get(entityId);
     }
-    readFpVector3(index, xKey, yKey, zKey) {
+    readFpPosition(index) {
+        const arrays = this.transformStore.arrays;
+        return {
+            x: FP.FromRaw(arrays.fpPositionX[index]),
+            y: FP.FromRaw(arrays.fpPositionY[index]),
+            z: FP.FromRaw(arrays.fpPositionZ[index]),
+        };
+    }
+    readFpRotation(index) {
         const arrays = this.transformStore.arrays;
         return {
-            x: FP.FromRaw(arrays[xKey][index]),
-            y: FP.FromRaw(arrays[yKey][index]),
-            z: FP.FromRaw(arrays[zKey][index]),
+            x: FP.FromRaw(arrays.fpRotationX[index]),
+            y: FP.FromRaw(arrays.fpRotationY[index]),
+            z: FP.FromRaw(arrays.fpRotationZ[index]),
+            w: FP.FromRaw(arrays.fpRotationW[index]),
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phalanx-engine/physics",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Deterministic fixed-point physics engine for Phalanx Engine - spatial hashing, collision detection, and resolution",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,8 +18,8 @@
   "devDependencies": {
     "typescript": "~5.9.3",
     "vitest": "^1.0.0",
-    "@phalanx-engine/ecs": "0.1.0",
-    "@phalanx-engine/math": "0.1.0"
+    "@phalanx-engine/ecs": "0.1.2",
+    "@phalanx-engine/math": "0.1.2"
   },
   "keywords": [
     "physics",