@phalanx-engine/physics 0.1.0

package/dist/collision/NarrowPhase.js

@@ -0,0 +1,112 @@
+import { FP } from '@phalanx-engine/math';
+const EPSILON = FP.FromFloat(0.0001);
+export class NarrowPhase {
+    static circleVsCircle(posAX, posAZ, radiusA, posBX, posBZ, radiusB, entityA, entityB) {
+        const dx = FP.Sub(posBX, posAX);
+        const dz = FP.Sub(posBZ, posAZ);
+        const distSq = FP.Add(FP.Mul(dx, dx), FP.Mul(dz, dz));
+        const minDist = FP.Add(radiusA, radiusB);
+        const minDistSq = FP.Mul(minDist, minDist);
+        if (FP.Gte(distSq, minDistSq)) {
+            return null;
+        }
+        if (FP.Lte(distSq, FP.Mul(EPSILON, EPSILON))) {
+            return {
+                entityA,
+                entityB,
+                normalX: FP._1,
+                normalZ: FP._0,
+                penetration: minDist,
+            };
+        }
+        const dist = FP.Sqrt(distSq);
+        const penetration = FP.Sub(minDist, dist);
+        const normalX = FP.Div(dx, dist);
+        const normalZ = FP.Div(dz, dist);
+        return { entityA, entityB, normalX, normalZ, penetration };
+    }
+    static circleVsAABB(circlePosX, circlePosZ, circleRadius, aabbMinX, aabbMinZ, aabbMaxX, aabbMaxZ, entityCircle, entityAABB) {
+        const closestX = FP.Clamp(circlePosX, aabbMinX, aabbMaxX);
+        const closestZ = FP.Clamp(circlePosZ, aabbMinZ, aabbMaxZ);
+        const dx = FP.Sub(circlePosX, closestX);
+        const dz = FP.Sub(circlePosZ, closestZ);
+        const distSq = FP.Add(FP.Mul(dx, dx), FP.Mul(dz, dz));
+        const radiusSq = FP.Mul(circleRadius, circleRadius);
+        if (FP.Gte(distSq, radiusSq)) {
+            return null;
+        }
+        if (FP.Lte(distSq, FP.Mul(EPSILON, EPSILON))) {
+            const halfW = FP.Mul(FP.Sub(aabbMaxX, aabbMinX), FP.FromFloat(0.5));
+            const halfH = FP.Mul(FP.Sub(aabbMaxZ, aabbMinZ), FP.FromFloat(0.5));
+            const centerX = FP.Add(aabbMinX, halfW);
+            const centerZ = FP.Add(aabbMinZ, halfH);
+            const ox = FP.Sub(circlePosX, centerX);
+            const oz = FP.Sub(circlePosZ, centerZ);
+            const overlapX = FP.Sub(FP.Add(halfW, circleRadius), FP.Abs(ox));
+            const overlapZ = FP.Sub(FP.Add(halfH, circleRadius), FP.Abs(oz));
+            if (FP.Lt(overlapX, overlapZ)) {
+                const sign = FP.Gte(ox, FP._0) ? FP._1 : FP.Neg(FP._1);
+                return {
+                    entityA: entityCircle,
+                    entityB: entityAABB,
+                    normalX: sign,
+                    normalZ: FP._0,
+                    penetration: overlapX,
+                };
+            }
+            else {
+                const sign = FP.Gte(oz, FP._0) ? FP._1 : FP.Neg(FP._1);
+                return {
+                    entityA: entityCircle,
+                    entityB: entityAABB,
+                    normalX: FP._0,
+                    normalZ: sign,
+                    penetration: overlapZ,
+                };
+            }
+        }
+        const dist = FP.Sqrt(distSq);
+        const penetration = FP.Sub(circleRadius, dist);
+        const normalX = FP.Div(dx, dist);
+        const normalZ = FP.Div(dz, dist);
+        return {
+            entityA: entityCircle,
+            entityB: entityAABB,
+            normalX,
+            normalZ,
+            penetration,
+        };
+    }
+    static aabbVsAABB(aMinX, aMinZ, aMaxX, aMaxZ, bMinX, bMinZ, bMaxX, bMaxZ, entityA, entityB) {
+        const overlapX1 = FP.Sub(aMaxX, bMinX);
+        const overlapX2 = FP.Sub(bMaxX, aMinX);
+        const overlapZ1 = FP.Sub(aMaxZ, bMinZ);
+        const overlapZ2 = FP.Sub(bMaxZ, aMinZ);
+        if (FP.Lte(overlapX1, FP._0) || FP.Lte(overlapX2, FP._0) ||
+            FP.Lte(overlapZ1, FP._0) || FP.Lte(overlapZ2, FP._0)) {
+            return null;
+        }
+        const minOverlapX = FP.Min(overlapX1, overlapX2);
+        const minOverlapZ = FP.Min(overlapZ1, overlapZ2);
+        if (FP.Lt(minOverlapX, minOverlapZ)) {
+            const sign = FP.Lt(overlapX1, overlapX2) ? FP._1 : FP.Neg(FP._1);
+            return {
+                entityA,
+                entityB,
+                normalX: sign,
+                normalZ: FP._0,
+                penetration: minOverlapX,
+            };
+        }
+        else {
+            const sign = FP.Lt(overlapZ1, overlapZ2) ? FP._1 : FP.Neg(FP._1);
+            return {
+                entityA,
+                entityB,
+                normalX: FP._0,
+                normalZ: sign,
+                penetration: minOverlapZ,
+            };
+        }
+    }
+}

package/dist/collision/SpatialHashGrid.d.ts

@@ -0,0 +1,19 @@
+import { type FixedPoint } from '@phalanx-engine/math';
+export declare class SpatialHashGrid {
+    private readonly cellSize;
+    private readonly cells;
+    private readonly entityCells;
+    private readonly entityPosX;
+    private readonly entityPosZ;
+    private readonly _pairsResult;
+    private readonly _radiusResult;
+    constructor(cellSize: FixedPoint);
+    insert(entityId: number, posX: FixedPoint, posZ: FixedPoint, radius: FixedPoint): void;
+    remove(entityId: number): void;
+    update(entityId: number, posX: FixedPoint, posZ: FixedPoint, radius: FixedPoint): void;
+    queryPairs(): [number, number][];
+    queryRadius(posX: FixedPoint, posZ: FixedPoint, radius: FixedPoint): number[];
+    clear(): void;
+    private getCoveredCells;
+}
+//# sourceMappingURL=SpatialHashGrid.d.ts.map

package/dist/collision/SpatialHashGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../src/collision/SpatialHashGrid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAM,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAW3D,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAG1D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoC;IAMhE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;IACjE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;IAGjE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0B;IAGvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;gBAElC,QAAQ,EAAE,UAAU;IAOzB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI;IAoBtF,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IA0B9B,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI;IActF,UAAU,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;IAuChC,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE;IAiC7E,KAAK,IAAI,IAAI;IAUpB,OAAO,CAAC,eAAe;CAmBxB"}

package/dist/collision/SpatialHashGrid.js

@@ -0,0 +1,125 @@
+import { FP } from '@phalanx-engine/math';
+export class SpatialHashGrid {
+    cellSize;
+    cells = new Map();
+    entityCells = new Map();
+    entityPosX = new Map();
+    entityPosZ = new Map();
+    _pairsResult = [];
+    _radiusResult = [];
+    constructor(cellSize) {
+        this.cellSize = cellSize;
+    }
+    insert(entityId, posX, posZ, radius) {
+        const cellKeys = this.getCoveredCells(posX, posZ, radius);
+        this.entityCells.set(entityId, cellKeys);
+        this.entityPosX.set(entityId, posX);
+        this.entityPosZ.set(entityId, posZ);
+        for (const key of cellKeys) {
+            let cell = this.cells.get(key);
+            if (!cell) {
+                cell = [];
+                this.cells.set(key, cell);
+            }
+            cell.push(entityId);
+        }
+    }
+    remove(entityId) {
+        const cellKeys = this.entityCells.get(entityId);
+        if (!cellKeys)
+            return;
+        for (const key of cellKeys) {
+            const cell = this.cells.get(key);
+            if (cell) {
+                const idx = cell.indexOf(entityId);
+                if (idx !== -1) {
+                    cell[idx] = cell[cell.length - 1];
+                    cell.pop();
+                }
+                if (cell.length === 0) {
+                    this.cells.delete(key);
+                }
+            }
+        }
+        this.entityCells.delete(entityId);
+        this.entityPosX.delete(entityId);
+        this.entityPosZ.delete(entityId);
+    }
+    update(entityId, posX, posZ, radius) {
+        this.remove(entityId);
+        this.insert(entityId, posX, posZ, radius);
+    }
+    queryPairs() {
+        this._pairsResult.length = 0;
+        const seen = new Set();
+        for (const cell of this.cells.values()) {
+            const len = cell.length;
+            for (let i = 0; i < len; i++) {
+                for (let j = i + 1; j < len; j++) {
+                    const a = cell[i];
+                    const b = cell[j];
+                    const lo = a < b ? a : b;
+                    const hi = a < b ? b : a;
+                    const key = `${lo},${hi}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        this._pairsResult.push([lo, hi]);
+                    }
+                }
+            }
+        }
+        this._pairsResult.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+        return this._pairsResult;
+    }
+    queryRadius(posX, posZ, radius) {
+        this._radiusResult.length = 0;
+        const seen = new Set();
+        const radiusSq = FP.Mul(radius, radius);
+        const cellKeys = this.getCoveredCells(posX, posZ, radius);
+        for (const key of cellKeys) {
+            const cell = this.cells.get(key);
+            if (!cell)
+                continue;
+            for (const id of cell) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                const px = this.entityPosX.get(id);
+                const pz = this.entityPosZ.get(id);
+                if (px === undefined || pz === undefined)
+                    continue;
+                const dx = FP.Sub(px, posX);
+                const dz = FP.Sub(pz, posZ);
+                const distanceSq = FP.Add(FP.Mul(dx, dx), FP.Mul(dz, dz));
+                if (FP.Lte(distanceSq, radiusSq)) {
+                    this._radiusResult.push(id);
+                }
+            }
+        }
+        this._radiusResult.sort((a, b) => a - b);
+        return this._radiusResult;
+    }
+    clear() {
+        this.cells.clear();
+        this.entityCells.clear();
+        this.entityPosX.clear();
+        this.entityPosZ.clear();
+    }
+    getCoveredCells(posX, posZ, radius) {
+        const minX = FP.Sub(posX, radius);
+        const maxX = FP.Add(posX, radius);
+        const minZ = FP.Sub(posZ, radius);
+        const maxZ = FP.Add(posZ, radius);
+        const cellMinX = FP.ToFloat(FP.Floor(FP.Div(minX, this.cellSize)));
+        const cellMaxX = FP.ToFloat(FP.Floor(FP.Div(maxX, this.cellSize)));
+        const cellMinZ = FP.ToFloat(FP.Floor(FP.Div(minZ, this.cellSize)));
+        const cellMaxZ = FP.ToFloat(FP.Floor(FP.Div(maxZ, this.cellSize)));
+        const keys = [];
+        for (let cx = cellMinX; cx <= cellMaxX; cx++) {
+            for (let cz = cellMinZ; cz <= cellMaxZ; cz++) {
+                keys.push(`${cx},${cz}`);
+            }
+        }
+        return keys;
+    }
+}

package/dist/collision/index.d.ts

@@ -0,0 +1,4 @@
+export type { CollisionManifold } from './CollisionManifold';
+export { SpatialHashGrid } from './SpatialHashGrid';
+export { NarrowPhase } from './NarrowPhase';
+//# sourceMappingURL=index.d.ts.map

package/dist/collision/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collision/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/collision/index.js

@@ -0,0 +1,2 @@
+export { SpatialHashGrid } from './SpatialHashGrid';
+export { NarrowPhase } from './NarrowPhase';

package/dist/components/InterpolationComponent.d.ts

@@ -0,0 +1,15 @@
+import type { IComponent } from '@phalanx-engine/ecs';
+import type { FPVector3 as FPVector3Type } 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);
+    snapshot(): void;
+    capture(fpPosition: FPVector3Type, fpRotation: FPVector3Type): void;
+    private copyFpVector3;
+}
+//# sourceMappingURL=InterpolationComponent.d.ts.map

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

@@ -0,0 +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"}

package/dist/components/InterpolationComponent.js

@@ -0,0 +1,32 @@
+import { FP } from '@phalanx-engine/math';
+export const INTERPOLATION_COMPONENT_TYPE = Symbol('Interpolation');
+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 };
+    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);
+        }
+    }
+    snapshot() {
+        this.copyFpVector3(this.previousFpPosition, this.currentFpPosition);
+        this.copyFpVector3(this.previousFpRotation, this.currentFpRotation);
+    }
+    capture(fpPosition, fpRotation) {
+        this.copyFpVector3(this.currentFpPosition, fpPosition);
+        this.copyFpVector3(this.currentFpRotation, fpRotation);
+    }
+    copyFpVector3(target, source) {
+        target.x = source.x;
+        target.y = source.y;
+        target.z = source.z;
+    }
+}

package/dist/components/PhysicsBodyComponent.d.ts

@@ -0,0 +1,53 @@
+import { SoAComponent } from '@phalanx-engine/ecs';
+import { type FixedPoint, type FPVector3 as FPVector3Type } from '@phalanx-engine/math';
+import type { PhysicsBodyConfig } from '../types';
+export declare const PhysicsSoASchema: import("@phalanx-engine/ecs").SoASchema<{
+    velocityX: "i64";
+    velocityY: "i64";
+    velocityZ: "i64";
+    radius: "i64";
+    mass: "i64";
+    restitution: "i64";
+    friction: "i64";
+    isStatic: "u8";
+    ignorePhysics: "u8";
+    lastX: "f64";
+    lastZ: "f64";
+}>;
+export declare const PHYSICS_BODY_COMPONENT_TYPE: symbol;
+export declare class PhysicsBodyComponent extends SoAComponent<typeof PhysicsSoASchema.definition> {
+    readonly type: symbol;
+    static readonly soaSchema: import("@phalanx-engine/ecs").SoASchema<{
+        velocityX: "i64";
+        velocityY: "i64";
+        velocityZ: "i64";
+        radius: "i64";
+        mass: "i64";
+        restitution: "i64";
+        friction: "i64";
+        isStatic: "u8";
+        ignorePhysics: "u8";
+        lastX: "f64";
+        lastZ: "f64";
+    }>;
+    private readonly _velocity;
+    constructor(entityId: number, config: PhysicsBodyConfig);
+    get velocity(): FPVector3Type;
+    set velocity(value: FPVector3Type);
+    setVelocity(x: FixedPoint, y: FixedPoint, z: FixedPoint): void;
+    addVelocity(velocity: FPVector3Type): void;
+    stopVelocity(): void;
+    get radius(): FixedPoint;
+    get radiusFloat(): number;
+    get mass(): FixedPoint;
+    get restitution(): FixedPoint;
+    get friction(): FixedPoint;
+    get isStatic(): boolean;
+    get ignorePhysics(): boolean;
+    set ignorePhysics(value: boolean);
+    get lastX(): number;
+    set lastX(value: number);
+    get lastZ(): number;
+    set lastZ(value: number);
+}
+//# sourceMappingURL=PhysicsBodyComponent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsBodyComponent.d.ts","sourceRoot":"","sources":["../../src/components/PhysicsBodyComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAmB,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAM,KAAK,UAAU,EAAE,KAAK,SAAS,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAQlD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAYZ,CAAC;AAMlB,eAAO,MAAM,2BAA2B,EAAE,MAA8B,CAAC;AAgBzE,qBAAa,oBAAqB,SAAQ,YAAY,CAAC,OAAO,gBAAgB,CAAC,UAAU,CAAC;IACxF,SAAgB,IAAI,SAA+B;IACnD,MAAM,CAAC,QAAQ,CAAC,SAAS;;;;;;;;;;;;OAAoB;IAG7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmD;gBAEjE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB;IA0BvD,IAAW,QAAQ,IAAI,aAAa,CAOnC;IAED,IAAW,QAAQ,CAAC,KAAK,EAAE,aAAa,EAMvC;IAGM,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,IAAI;IAS9D,WAAW,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAY1C,YAAY,IAAI,IAAI;IAW3B,IAAW,MAAM,IAAI,UAAU,CAI9B;IAED,IAAW,WAAW,IAAI,MAAM,CAI/B;IAID,IAAW,IAAI,IAAI,UAAU,CAI5B;IAID,IAAW,WAAW,IAAI,UAAU,CAInC;IAID,IAAW,QAAQ,IAAI,UAAU,CAIhC;IAID,IAAW,QAAQ,IAAI,OAAO,CAI7B;IAID,IAAW,aAAa,IAAI,OAAO,CAIlC;IAED,IAAW,aAAa,CAAC,KAAK,EAAE,OAAO,EAItC;IAID,IAAW,KAAK,IAAI,MAAM,CAIzB;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,EAI7B;IAED,IAAW,KAAK,IAAI,MAAM,CAIzB;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,EAI7B;CACF"}

package/dist/components/PhysicsBodyComponent.js

@@ -0,0 +1,157 @@
+import { SoAComponent, defineSoASchema } from '@phalanx-engine/ecs';
+import { FP } from '@phalanx-engine/math';
+export const PhysicsSoASchema = defineSoASchema({
+    velocityX: 'i64',
+    velocityY: 'i64',
+    velocityZ: 'i64',
+    radius: 'i64',
+    mass: 'i64',
+    restitution: 'i64',
+    friction: 'i64',
+    isStatic: 'u8',
+    ignorePhysics: 'u8',
+    lastX: 'f64',
+    lastZ: 'f64',
+}, 'PhysicsBody');
+export const PHYSICS_BODY_COMPONENT_TYPE = Symbol('PhysicsBody');
+export class PhysicsBodyComponent extends SoAComponent {
+    type = PHYSICS_BODY_COMPONENT_TYPE;
+    static soaSchema = PhysicsSoASchema;
+    _velocity = { x: FP._0, y: FP._0, z: FP._0 };
+    constructor(entityId, config) {
+        const mass = config.mass ?? FP._1;
+        const restitution = config.restitution ?? FP.FromFloat(0.5);
+        const friction = config.friction ?? FP._0;
+        const isStatic = config.isStatic ?? false;
+        super(PhysicsSoASchema, entityId, {
+            velocityX: FP.ToRaw(FP._0),
+            velocityY: FP.ToRaw(FP._0),
+            velocityZ: FP.ToRaw(FP._0),
+            radius: FP.ToRaw(config.radius),
+            mass: FP.ToRaw(mass),
+            restitution: FP.ToRaw(restitution),
+            friction: FP.ToRaw(friction),
+            isStatic: isStatic ? 1 : 0,
+            ignorePhysics: 0,
+            lastX: 0,
+            lastZ: 0,
+        });
+    }
+    get velocity() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return this._velocity;
+        this._velocity.x = FP.FromRaw(this.store.arrays.velocityX[idx]);
+        this._velocity.y = FP.FromRaw(this.store.arrays.velocityY[idx]);
+        this._velocity.z = FP.FromRaw(this.store.arrays.velocityZ[idx]);
+        return this._velocity;
+    }
+    set velocity(value) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        this.store.arrays.velocityX[idx] = FP.ToRaw(value.x);
+        this.store.arrays.velocityY[idx] = FP.ToRaw(value.y);
+        this.store.arrays.velocityZ[idx] = FP.ToRaw(value.z);
+    }
+    setVelocity(x, y, z) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        this.store.arrays.velocityX[idx] = FP.ToRaw(x);
+        this.store.arrays.velocityY[idx] = FP.ToRaw(y);
+        this.store.arrays.velocityZ[idx] = FP.ToRaw(z);
+    }
+    addVelocity(velocity) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        const currentX = FP.FromRaw(this.store.arrays.velocityX[idx]);
+        const currentY = FP.FromRaw(this.store.arrays.velocityY[idx]);
+        const currentZ = FP.FromRaw(this.store.arrays.velocityZ[idx]);
+        this.store.arrays.velocityX[idx] = FP.ToRaw(FP.Add(currentX, velocity.x));
+        this.store.arrays.velocityY[idx] = FP.ToRaw(FP.Add(currentY, velocity.y));
+        this.store.arrays.velocityZ[idx] = FP.ToRaw(FP.Add(currentZ, velocity.z));
+    }
+    stopVelocity() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        const zero = FP.ToRaw(FP._0);
+        this.store.arrays.velocityX[idx] = zero;
+        this.store.arrays.velocityY[idx] = zero;
+        this.store.arrays.velocityZ[idx] = zero;
+    }
+    get radius() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return FP._1;
+        return FP.FromRaw(this.store.arrays.radius[idx]);
+    }
+    get radiusFloat() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return 1;
+        return FP.ToFloat(FP.FromRaw(this.store.arrays.radius[idx]));
+    }
+    get mass() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return FP._1;
+        return FP.FromRaw(this.store.arrays.mass[idx]);
+    }
+    get restitution() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return FP.FromFloat(0.5);
+        return FP.FromRaw(this.store.arrays.restitution[idx]);
+    }
+    get friction() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return FP.FromFloat(0.3);
+        return FP.FromRaw(this.store.arrays.friction[idx]);
+    }
+    get isStatic() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return false;
+        return this.store.arrays.isStatic[idx] === 1;
+    }
+    get ignorePhysics() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return false;
+        return this.store.arrays.ignorePhysics[idx] === 1;
+    }
+    set ignorePhysics(value) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        this.store.arrays.ignorePhysics[idx] = value ? 1 : 0;
+    }
+    get lastX() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return 0;
+        return this.store.arrays.lastX[idx];
+    }
+    set lastX(value) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        this.store.arrays.lastX[idx] = value;
+    }
+    get lastZ() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return 0;
+        return this.store.arrays.lastZ[idx];
+    }
+    set lastZ(value) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        this.store.arrays.lastZ[idx] = value;
+    }
+}

package/dist/components/TransformComponent.d.ts

@@ -0,0 +1,32 @@
+import { SoAComponent } from '@phalanx-engine/ecs';
+import { type FixedPoint, type FPVector3 as FPVector3Type } from '@phalanx-engine/math';
+export declare const TransformSoASchema: import("@phalanx-engine/ecs").SoASchema<{
+    fpPositionX: "i64";
+    fpPositionY: "i64";
+    fpPositionZ: "i64";
+    fpRotationX: "i64";
+    fpRotationY: "i64";
+    fpRotationZ: "i64";
+}>;
+export declare const TRANSFORM_COMPONENT_TYPE: symbol;
+export declare class TransformComponent extends SoAComponent<typeof TransformSoASchema.definition> {
+    readonly type: symbol;
+    static readonly soaSchema: import("@phalanx-engine/ecs").SoASchema<{
+        fpPositionX: "i64";
+        fpPositionY: "i64";
+        fpPositionZ: "i64";
+        fpRotationX: "i64";
+        fpRotationY: "i64";
+        fpRotationZ: "i64";
+    }>;
+    private readonly _fpPosition;
+    private readonly _fpRotation;
+    constructor(entityId: number, initialPosition?: FPVector3Type, initialRotation?: FPVector3Type);
+    get fpPosition(): FPVector3Type;
+    set fpPosition(value: FPVector3Type);
+    get fpRotation(): FPVector3Type;
+    set fpRotation(value: FPVector3Type);
+    get fpRotationY(): FixedPoint;
+    set fpRotationY(value: FixedPoint);
+}
+//# sourceMappingURL=TransformComponent.d.ts.map

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

@@ -0,0 +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"}

package/dist/components/TransformComponent.js

@@ -0,0 +1,75 @@
+import { SoAComponent, defineSoASchema } from '@phalanx-engine/ecs';
+import { FP, FPVector3 } from '@phalanx-engine/math';
+export const TransformSoASchema = defineSoASchema({
+    fpPositionX: 'i64',
+    fpPositionY: 'i64',
+    fpPositionZ: 'i64',
+    fpRotationX: 'i64',
+    fpRotationY: 'i64',
+    fpRotationZ: '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 };
+    constructor(entityId, initialPosition, initialRotation) {
+        const position = initialPosition ?? FPVector3.Zero;
+        const rotation = initialRotation ?? FPVector3.Zero;
+        super(TransformSoASchema, entityId, {
+            fpPositionX: FP.ToRaw(position.x),
+            fpPositionY: FP.ToRaw(position.y),
+            fpPositionZ: FP.ToRaw(position.z),
+            fpRotationX: FP.ToRaw(rotation.x),
+            fpRotationY: FP.ToRaw(rotation.y),
+            fpRotationZ: FP.ToRaw(rotation.z),
+        });
+    }
+    get fpPosition() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return this._fpPosition;
+        this._fpPosition.x = FP.FromRaw(this.store.arrays.fpPositionX[idx]);
+        this._fpPosition.y = FP.FromRaw(this.store.arrays.fpPositionY[idx]);
+        this._fpPosition.z = FP.FromRaw(this.store.arrays.fpPositionZ[idx]);
+        return this._fpPosition;
+    }
+    set fpPosition(value) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        this.store.arrays.fpPositionX[idx] = FP.ToRaw(value.x);
+        this.store.arrays.fpPositionY[idx] = FP.ToRaw(value.y);
+        this.store.arrays.fpPositionZ[idx] = FP.ToRaw(value.z);
+    }
+    get fpRotation() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return this._fpRotation;
+        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]);
+        return this._fpRotation;
+    }
+    set fpRotation(value) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        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);
+    }
+    get fpRotationY() {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return FP._0;
+        return FP.FromRaw(this.store.arrays.fpRotationY[idx]);
+    }
+    set fpRotationY(value) {
+        const idx = this.getIndex();
+        if (idx === -1)
+            return;
+        this.store.arrays.fpRotationY[idx] = FP.ToRaw(value);
+    }
+}

package/dist/components/index.d.ts

@@ -0,0 +1,4 @@
+export { PhysicsBodyComponent, PhysicsSoASchema, PHYSICS_BODY_COMPONENT_TYPE } from './PhysicsBodyComponent';
+export { TransformComponent, TransformSoASchema, TRANSFORM_COMPONENT_TYPE } from './TransformComponent';
+export { InterpolationComponent, INTERPOLATION_COMPONENT_TYPE, } from './InterpolationComponent';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC7G,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACxG,OAAO,EACL,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,0BAA0B,CAAC"}

package/dist/components/index.js

@@ -0,0 +1,3 @@
+export { PhysicsBodyComponent, PhysicsSoASchema, PHYSICS_BODY_COMPONENT_TYPE } from './PhysicsBodyComponent';
+export { TransformComponent, TransformSoASchema, TRANSFORM_COMPONENT_TYPE } from './TransformComponent';
+export { InterpolationComponent, INTERPOLATION_COMPONENT_TYPE, } from './InterpolationComponent';