@phalanx-engine/physics 0.1.0

package/dist/events.d.ts

@@ -0,0 +1,7 @@
+export declare const PhysicsEvents: {
+    readonly COLLISION: "physics:collision";
+    readonly TRIGGER_ENTER: "physics:trigger:enter";
+    readonly TRIGGER_EXIT: "physics:trigger:exit";
+    readonly BOUNDS_EXIT: "physics:bounds:exit";
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;CAMhB,CAAC"}

package/dist/events.js

@@ -0,0 +1,6 @@
+export const PhysicsEvents = {
+    COLLISION: 'physics:collision',
+    TRIGGER_ENTER: 'physics:trigger:enter',
+    TRIGGER_EXIT: 'physics:trigger:exit',
+    BOUNDS_EXIT: 'physics:bounds:exit',
+};

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { PhysicsBodyComponent, PhysicsSoASchema, PHYSICS_BODY_COMPONENT_TYPE, TransformComponent, TransformSoASchema, TRANSFORM_COMPONENT_TYPE, InterpolationComponent, INTERPOLATION_COMPONENT_TYPE, } from './components';
+export type { PhysicsBodyConfig } from './types';
+export { SpatialHashGrid } from './collision/SpatialHashGrid';
+export { NarrowPhase } from './collision/NarrowPhase';
+export type { CollisionManifold } from './collision/CollisionManifold';
+export { PhysicsSystem, InterpolationSystem } from './systems';
+export type { InterpolatedTransformSample } from './systems';
+export { PhysicsWorld } from './PhysicsWorld';
+export type { PhysicsWorldConfig } from './PhysicsWorldConfig';
+export type { CollisionFilter, CollisionEvent, PhysicsConfig } from './types';
+export { PhysicsEvents } from './events';
+export type { IPhysicsTickProvider } from './tick/IPhysicsTickProvider';
+export { AutonomousPhysicsTickProvider } from './tick/AutonomousPhysicsTickProvider';
+export type { AutonomousProviderOptions } from './tick/AutonomousPhysicsTickProvider';
+export { ExternalPhysicsTickProvider } from './tick/ExternalPhysicsTickProvider';
+export type { BoundsExitEvent } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,2BAA2B,EAC3B,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,YAAY,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAGvE,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC/D,YAAY,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AAG7D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,YAAY,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AACrF,YAAY,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACtF,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AACjF,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export { PhysicsBodyComponent, PhysicsSoASchema, PHYSICS_BODY_COMPONENT_TYPE, TransformComponent, TransformSoASchema, TRANSFORM_COMPONENT_TYPE, InterpolationComponent, INTERPOLATION_COMPONENT_TYPE, } from './components';
+export { SpatialHashGrid } from './collision/SpatialHashGrid';
+export { NarrowPhase } from './collision/NarrowPhase';
+export { PhysicsSystem, InterpolationSystem } from './systems';
+export { PhysicsWorld } from './PhysicsWorld';
+export { PhysicsEvents } from './events';
+export { AutonomousPhysicsTickProvider } from './tick/AutonomousPhysicsTickProvider';
+export { ExternalPhysicsTickProvider } from './tick/ExternalPhysicsTickProvider';

package/dist/systems/CollisionSystem.d.ts

@@ -0,0 +1,20 @@
+import { GameSystem, type SystemContext } from '@phalanx-engine/ecs';
+import { type FixedPoint } from '@phalanx-engine/math';
+import { SpatialHashGrid } from '../collision/SpatialHashGrid';
+export declare class CollisionSystem extends GameSystem {
+    private physicsStore;
+    private transformStore;
+    private readonly spatialGrid;
+    private pushStrength;
+    private collisionFilter;
+    constructor(gridCellSize: FixedPoint, pushStrength?: FixedPoint);
+    setCollisionFilter(filter: (entityA: number, entityB: number) => boolean): void;
+    init(context: SystemContext): void;
+    getSpatialGrid(): SpatialHashGrid;
+    processTick(_tick: number): void;
+    private rebuildSpatialGrid;
+    private detectAndResolve;
+    private resolveCollision;
+    dispose(): void;
+}
+//# sourceMappingURL=CollisionSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CollisionSystem.d.ts","sourceRoot":"","sources":["../../src/systems/CollisionSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA0B,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC7F,OAAO,EAAM,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAe/D,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAO,CAAC,YAAY,CAAyD;IAC7E,OAAO,CAAC,cAAc,CAA2D;IACjF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkB;IAC9C,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,eAAe,CAAgE;gBAE3E,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,EAAE,UAAU;IAUxD,kBAAkB,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI;IAItE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAO3C,cAAc,IAAI,eAAe;IAIxB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQhD,OAAO,CAAC,kBAAkB;IA8B1B,OAAO,CAAC,gBAAgB;IAyExB,OAAO,CAAC,gBAAgB;IAkER,OAAO,IAAI,IAAI;CAIhC"}

package/dist/systems/CollisionSystem.js

@@ -0,0 +1,150 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { FP } from '@phalanx-engine/math';
+import { PhysicsSoASchema } from '../components/PhysicsBodyComponent';
+import { TransformSoASchema } from '../components/TransformComponent';
+import { SpatialHashGrid } from '../collision/SpatialHashGrid';
+import { NarrowPhase } from '../collision/NarrowPhase';
+import { PhysicsEvents } from '../events';
+const SEPARATION_HALF = FP.FromFloat(0.5);
+export class CollisionSystem extends GameSystem {
+    physicsStore;
+    transformStore;
+    spatialGrid;
+    pushStrength;
+    collisionFilter = null;
+    constructor(gridCellSize, pushStrength) {
+        super();
+        this.spatialGrid = new SpatialHashGrid(gridCellSize);
+        this.pushStrength = pushStrength ?? FP.FromFloat(15.0);
+    }
+    setCollisionFilter(filter) {
+        this.collisionFilter = filter;
+    }
+    init(context) {
+        super.init(context);
+        this.physicsStore = this.entityManager.getOrCreateSoAStore(PhysicsSoASchema);
+        this.transformStore = this.entityManager.getOrCreateSoAStore(TransformSoASchema);
+    }
+    getSpatialGrid() {
+        return this.spatialGrid;
+    }
+    processTick(_tick) {
+        this.rebuildSpatialGrid();
+        this.detectAndResolve();
+    }
+    rebuildSpatialGrid() {
+        this.spatialGrid.clear();
+        const physLastX = this.physicsStore.arrays.lastX;
+        const physLastZ = this.physicsStore.arrays.lastZ;
+        const physRadius = this.physicsStore.arrays.radius;
+        const fpPosXArr = this.transformStore.arrays.fpPositionX;
+        const fpPosZArr = this.transformStore.arrays.fpPositionZ;
+        for (const entityId of this.physicsStore.entityIds()) {
+            const physIndex = this.physicsStore.indexOf(entityId);
+            const transformIndex = this.transformStore.indexOf(entityId);
+            if (transformIndex === -1)
+                continue;
+            const posX = FP.FromRaw(fpPosXArr[transformIndex]);
+            const posZ = FP.FromRaw(fpPosZArr[transformIndex]);
+            const radius = FP.FromRaw(physRadius[physIndex]);
+            physLastX[physIndex] = FP.ToFloat(posX);
+            physLastZ[physIndex] = FP.ToFloat(posZ);
+            this.spatialGrid.insert(entityId, posX, posZ, radius);
+        }
+    }
+    detectAndResolve() {
+        const pairs = this.spatialGrid.queryPairs();
+        const physVelocityX = this.physicsStore.arrays.velocityX;
+        const physVelocityZ = this.physicsStore.arrays.velocityZ;
+        const physRadius = this.physicsStore.arrays.radius;
+        const physMass = this.physicsStore.arrays.mass;
+        const physIsStatic = this.physicsStore.arrays.isStatic;
+        const physIgnorePhysics = this.physicsStore.arrays.ignorePhysics;
+        const fpPosXArr = this.transformStore.arrays.fpPositionX;
+        const fpPosZArr = this.transformStore.arrays.fpPositionZ;
+        for (const [entityIdA, entityIdB] of pairs) {
+            const physIndexA = this.physicsStore.indexOf(entityIdA);
+            const physIndexB = this.physicsStore.indexOf(entityIdB);
+            if (physIndexA === -1 || physIndexB === -1)
+                continue;
+            if (physIgnorePhysics[physIndexA] === 1 || physIgnorePhysics[physIndexB] === 1) {
+                continue;
+            }
+            if (this.collisionFilter && !this.collisionFilter(entityIdA, entityIdB)) {
+                continue;
+            }
+            const transformIndexA = this.transformStore.indexOf(entityIdA);
+            const transformIndexB = this.transformStore.indexOf(entityIdB);
+            if (transformIndexA === -1 || transformIndexB === -1)
+                continue;
+            const posAX = FP.FromRaw(fpPosXArr[transformIndexA]);
+            const posAZ = FP.FromRaw(fpPosZArr[transformIndexA]);
+            const posBX = FP.FromRaw(fpPosXArr[transformIndexB]);
+            const posBZ = FP.FromRaw(fpPosZArr[transformIndexB]);
+            const radiusA = FP.FromRaw(physRadius[physIndexA]);
+            const radiusB = FP.FromRaw(physRadius[physIndexB]);
+            const manifold = NarrowPhase.circleVsCircle(posAX, posAZ, radiusA, posBX, posBZ, radiusB, entityIdA, entityIdB);
+            if (!manifold)
+                continue;
+            this.resolveCollision(manifold, physIndexA, physIndexB, transformIndexA, transformIndexB, physVelocityX, physVelocityZ, physMass, physIsStatic, fpPosXArr, fpPosZArr);
+            const event = {
+                entityA: entityIdA,
+                entityB: entityIdB,
+                manifold,
+            };
+            this.eventBus.emit(PhysicsEvents.COLLISION, event);
+        }
+    }
+    resolveCollision(manifold, physIndexA, physIndexB, transformIndexA, transformIndexB, physVelocityX, physVelocityZ, physMass, physIsStatic, fpPosXArr, fpPosZArr) {
+        const isStaticA = physIsStatic[physIndexA] === 1;
+        const isStaticB = physIsStatic[physIndexB] === 1;
+        if (isStaticA && isStaticB)
+            return;
+        const massA = FP.FromRaw(physMass[physIndexA]);
+        const massB = FP.FromRaw(physMass[physIndexB]);
+        const totalMass = FP.Add(massA, massB);
+        const nx = manifold.normalX;
+        const nz = manifold.normalZ;
+        const overlap = manifold.penetration;
+        const pushForce = FP.Mul(overlap, this.pushStrength);
+        const ratioA = isStaticA ? FP._0 : (isStaticB ? FP._1 : FP.Div(massB, totalMass));
+        const ratioB = isStaticB ? FP._0 : (isStaticA ? FP._1 : FP.Div(massA, totalMass));
+        if (!isStaticA) {
+            const pushA = FP.Mul(pushForce, ratioA);
+            const velAx = FP.FromRaw(physVelocityX[physIndexA]);
+            const velAz = FP.FromRaw(physVelocityZ[physIndexA]);
+            physVelocityX[physIndexA] = FP.ToRaw(FP.Sub(velAx, FP.Mul(nx, pushA)));
+            physVelocityZ[physIndexA] = FP.ToRaw(FP.Sub(velAz, FP.Mul(nz, pushA)));
+        }
+        if (!isStaticB) {
+            const pushB = FP.Mul(pushForce, ratioB);
+            const velBx = FP.FromRaw(physVelocityX[physIndexB]);
+            const velBz = FP.FromRaw(physVelocityZ[physIndexB]);
+            physVelocityX[physIndexB] = FP.ToRaw(FP.Add(velBx, FP.Mul(nx, pushB)));
+            physVelocityZ[physIndexB] = FP.ToRaw(FP.Add(velBz, FP.Mul(nz, pushB)));
+        }
+        const separation = FP.Mul(overlap, SEPARATION_HALF);
+        if (!isStaticA) {
+            const sepA = FP.Mul(separation, ratioA);
+            const posAX = FP.FromRaw(fpPosXArr[transformIndexA]);
+            const posAZ = FP.FromRaw(fpPosZArr[transformIndexA]);
+            const newAX = FP.Sub(posAX, FP.Mul(nx, sepA));
+            const newAZ = FP.Sub(posAZ, FP.Mul(nz, sepA));
+            fpPosXArr[transformIndexA] = FP.ToRaw(newAX);
+            fpPosZArr[transformIndexA] = FP.ToRaw(newAZ);
+        }
+        if (!isStaticB) {
+            const sepB = FP.Mul(separation, ratioB);
+            const posBX = FP.FromRaw(fpPosXArr[transformIndexB]);
+            const posBZ = FP.FromRaw(fpPosZArr[transformIndexB]);
+            const newBX = FP.Add(posBX, FP.Mul(nx, sepB));
+            const newBZ = FP.Add(posBZ, FP.Mul(nz, sepB));
+            fpPosXArr[transformIndexB] = FP.ToRaw(newBX);
+            fpPosZArr[transformIndexB] = FP.ToRaw(newBZ);
+        }
+    }
+    dispose() {
+        super.dispose();
+        this.spatialGrid.clear();
+    }
+}

package/dist/systems/InterpolationSystem.d.ts

@@ -0,0 +1,28 @@
+import { GameSystem, type CommandsBatch, type IAfterTick, type IBeforeFrame, type IBeforeTick, type SystemContext } from '@phalanx-engine/ecs';
+export interface InterpolatedTransformSample {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export declare class InterpolationSystem extends GameSystem implements IBeforeTick, IAfterTick, IBeforeFrame {
+    private transformStore;
+    private readonly interpolatedSamples;
+    private readonly capturedEntities;
+    init(context: SystemContext): void;
+    beforeTick(_tick: number, _commands: CommandsBatch): void;
+    afterTick(_tick: number): void;
+    beforeFrame(alpha: number, _dt: number): void;
+    snapshot(): void;
+    capture(): void;
+    interpolate(alpha: number): void;
+    getInterpolatedTransform(entityId: number): InterpolatedTransformSample | undefined;
+    private readFpVector3;
+}
+//# sourceMappingURL=InterpolationSystem.d.ts.map

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

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

package/dist/systems/InterpolationSystem.js

@@ -0,0 +1,104 @@
+import { GameSystem, } from '@phalanx-engine/ecs';
+import { FP, FPVector3 } 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;
+}
+export class InterpolationSystem extends GameSystem {
+    transformStore;
+    interpolatedSamples = new Map();
+    capturedEntities = new Set();
+    init(context) {
+        super.init(context);
+        this.transformStore = this.entityManager.getOrCreateSoAStore(TransformSoASchema);
+    }
+    beforeTick(_tick, _commands) {
+        this.snapshot();
+    }
+    afterTick(_tick) {
+        this.capture();
+    }
+    beforeFrame(alpha, _dt) {
+        this.interpolate(alpha);
+    }
+    snapshot() {
+        const entities = this.entityManager.queryEntities(INTERPOLATION_COMPONENT_TYPE);
+        for (const entity of entities) {
+            entity.getComponent(INTERPOLATION_COMPONENT_TYPE)?.snapshot();
+        }
+    }
+    capture() {
+        const entities = this.entityManager.queryEntities(INTERPOLATION_COMPONENT_TYPE, TRANSFORM_COMPONENT_TYPE);
+        const activeEntityIds = new Set();
+        for (const entity of entities) {
+            activeEntityIds.add(entity.id);
+            const interpolation = entity.getComponent(INTERPOLATION_COMPONENT_TYPE);
+            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');
+            if (!this.capturedEntities.has(entity.id)) {
+                interpolation.capture(fpPosition, fpRotation);
+                interpolation.snapshot();
+                this.capturedEntities.add(entity.id);
+                continue;
+            }
+            interpolation.capture(fpPosition, fpRotation);
+        }
+        for (const entityId of this.capturedEntities) {
+            if (!activeEntityIds.has(entityId)) {
+                this.capturedEntities.delete(entityId);
+                this.interpolatedSamples.delete(entityId);
+            }
+        }
+    }
+    interpolate(alpha) {
+        const clampedAlpha = Math.max(0, Math.min(1, alpha));
+        this.interpolatedSamples.clear();
+        const entities = this.entityManager.queryEntities(INTERPOLATION_COMPONENT_TYPE, TRANSFORM_COMPONENT_TYPE);
+        for (const entity of entities) {
+            const interpolation = entity.getComponent(INTERPOLATION_COMPONENT_TYPE);
+            if (!interpolation)
+                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);
+            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),
+                },
+            });
+        }
+    }
+    getInterpolatedTransform(entityId) {
+        return this.interpolatedSamples.get(entityId);
+    }
+    readFpVector3(index, xKey, yKey, zKey) {
+        const arrays = this.transformStore.arrays;
+        return {
+            x: FP.FromRaw(arrays[xKey][index]),
+            y: FP.FromRaw(arrays[yKey][index]),
+            z: FP.FromRaw(arrays[zKey][index]),
+        };
+    }
+}

package/dist/systems/PhysicsSystem.d.ts

@@ -0,0 +1,41 @@
+import { GameSystem, type EventBus, type SoAComponentStore, type SystemContext } from '@phalanx-engine/ecs';
+import { type FixedPoint } from '@phalanx-engine/math';
+import { PhysicsSoASchema } from '../components/PhysicsBodyComponent';
+import { TransformSoASchema } from '../components/TransformComponent';
+import { SpatialHashGrid } from '../collision/SpatialHashGrid';
+import type { PhysicsConfig } from '../types';
+import type { IPhysicsTickProvider } from '../tick/IPhysicsTickProvider';
+export declare class PhysicsSystem extends GameSystem {
+    private physicsStore;
+    private transformStore;
+    private config;
+    private readonly spatialGrid;
+    private collisionFilter;
+    private externalTickProvider;
+    private providerStarted;
+    constructor(config: PhysicsConfig);
+    init(context: SystemContext): void;
+    private tryStartProvider;
+    setCollisionFilter(filter: (entityA: number, entityB: number) => boolean): void;
+    step(): void;
+    processTick(_tick: number): void;
+    setTickProvider(provider: IPhysicsTickProvider): void;
+    applyImpulse(entityId: number, vx: FixedPoint, vz: FixedPoint): void;
+    isSettled(threshold?: FixedPoint): boolean;
+    private applyVelocities;
+    private rebuildSpatialGrid;
+    private detectAndResolve;
+    private resolveCollision;
+    private applyFriction;
+    getPhysicsStore(): SoAComponentStore<typeof PhysicsSoASchema.definition>;
+    getTransformStore(): SoAComponentStore<typeof TransformSoASchema.definition>;
+    getConfig(): PhysicsConfig;
+    getEntityPosition(entityId: number): {
+        x: FixedPoint;
+        z: FixedPoint;
+    } | undefined;
+    getSpatialGrid(): SpatialHashGrid;
+    getEventBus(): EventBus;
+    dispose(): void;
+}
+//# sourceMappingURL=PhysicsSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../src/systems/PhysicsSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,KAAK,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC5G,OAAO,EAAM,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAI/D,OAAO,KAAK,EAAE,aAAa,EAAmC,MAAM,UAAU,CAAC;AAC/E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAgBzE,qBAAa,aAAc,SAAQ,UAAU;IAC3C,OAAO,CAAC,YAAY,CAAyD;IAC7E,OAAO,CAAC,cAAc,CAA2D;IACjF,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkB;IAC9C,OAAO,CAAC,eAAe,CAAgE;IACvF,OAAO,CAAC,oBAAoB,CAAqC;IACjE,OAAO,CAAC,eAAe,CAAS;gBAEpB,MAAM,EAAE,aAAa;IAMjB,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAWlD,OAAO,CAAC,gBAAgB;IAejB,kBAAkB,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI;IAQ/E,IAAI,IAAI,IAAI;IAUH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMzC,eAAe,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAerD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,GAAG,IAAI;IAiBpE,SAAS,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,OAAO;IAsBjD,OAAO,CAAC,eAAe;IA8EvB,OAAO,CAAC,kBAAkB;IA8B1B,OAAO,CAAC,gBAAgB;IAkFxB,OAAO,CAAC,gBAAgB;IAuExB,OAAO,CAAC,aAAa;IAwBd,eAAe,IAAI,iBAAiB,CAAC,OAAO,gBAAgB,CAAC,UAAU,CAAC;IAKxE,iBAAiB,IAAI,iBAAiB,CAAC,OAAO,kBAAkB,CAAC,UAAU,CAAC;IAK5E,SAAS,IAAI,aAAa;IAQ1B,iBAAiB,CACtB,QAAQ,EAAE,MAAM,GACf;QAAE,CAAC,EAAE,UAAU,CAAC;QAAC,CAAC,EAAE,UAAU,CAAA;KAAE,GAAG,SAAS;IAkBxC,cAAc,IAAI,eAAe;IAKjC,WAAW,IAAI,QAAQ;IAId,OAAO,IAAI,IAAI;CAMhC"}