@phalanx-engine/physics 0.1.0 → 0.1.1

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,CAEnC;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,18 @@ 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]);
+        return this.fpRotationEuler.y;
     }
     set fpRotationY(value) {
-        const idx = this.getIndex();
-        if (idx === -1)
-            return;
-        this.store.arrays.fpRotationY[idx] = FP.ToRaw(value);
+        this.fpRotation = FPQuaternion.FromAxisAngle(FPVector3.Up, 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.1",
   "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.1",
+    "@phalanx-engine/math": "0.1.1"
   },
   "keywords": [
     "physics",