@ue-too/dynamics 0.6.0 → 0.7.2

package/README.md

@@ -0,0 +1,7 @@
+# dynamics
+
+This is a library that provides a 2D physics engine with collision detection, rigid bodies, and constraints.
+
+Please _**DO NOT**_ use this in production.
+
+Detailed information would be added in the future.

package/benchmark.d.ts

@@ -0,0 +1,47 @@
+import { Point } from "@ue-too/math";
+interface MockRigidBody {
+    AABB: {
+        min: Point;
+        max: Point;
+    };
+    id: number;
+    velocity: Point;
+    isStatic(): boolean;
+}
+declare class MockStaticBody implements MockRigidBody {
+    AABB: {
+        min: Point;
+        max: Point;
+    };
+    id: number;
+    velocity: Point;
+    constructor(id: number, x: number, y: number, width: number, height: number);
+    isStatic(): boolean;
+}
+declare class MockDynamicBody implements MockRigidBody {
+    AABB: {
+        min: Point;
+        max: Point;
+    };
+    id: number;
+    velocity: Point;
+    constructor(id: number, x: number, y: number, width: number, height: number, vx?: number, vy?: number);
+    isStatic(): boolean;
+    update(dt: number): void;
+}
+declare class SpatialIndexBenchmark {
+    private scenarios;
+    constructor();
+    private setupScenarios;
+    private createDenseCluster;
+    private createRandomDistribution;
+    private createMovingObjects;
+    private createLineFormation;
+    private createMixedSizes;
+    private benchmarkQuadTree;
+    private benchmarkDynamicTree;
+    private benchmarkSweepAndPrune;
+    run(): void;
+}
+export { SpatialIndexBenchmark, MockRigidBody, MockDynamicBody, MockStaticBody };
+export declare function runBenchmark(): void;

package/collision-filter.d.ts

@@ -0,0 +1,17 @@
+export interface CollisionFilter {
+    category: number;
+    mask: number;
+    group: number;
+}
+export declare const DEFAULT_COLLISION_FILTER: CollisionFilter;
+export declare function canCollide(filterA: CollisionFilter, filterB: CollisionFilter): boolean;
+export declare const CollisionCategory: {
+    readonly STATIC: 1;
+    readonly DYNAMIC: 2;
+    readonly PLAYER: 4;
+    readonly ENEMY: 8;
+    readonly PROJECTILE: 16;
+    readonly SENSOR: 32;
+    readonly PICKUP: 64;
+    readonly PLATFORM: 128;
+};

package/collision.d.ts

@@ -26,11 +26,32 @@ export declare function narrowPhase(bodies: BaseRigidBody[], combinationsToCheck
     bodyAIndex: number;
     bodyBIndex: number;
 }[], resolveCollisionFlag: boolean): void;
-export declare function broadPhaseWithRigidBodyReturned(quadTree: QuadTree, bodies: RigidBody[]): {
+export declare function broadPhaseWithRigidBodyReturned(quadTree: QuadTree<RigidBody>, bodies: RigidBody[]): {
     bodyA: RigidBody;
     bodyB: RigidBody;
 }[];
-export declare function broadPhase(quadTree: QuadTree, bodies: BaseRigidBody[]): {
+export declare function broadPhaseWithSpatialIndex(spatialIndex: import("./dynamic-tree").SpatialIndex<RigidBody>, bodies: RigidBody[]): {
+    bodyA: RigidBody;
+    bodyB: RigidBody;
+}[];
+export declare function broadPhase(quadTree: QuadTree<RigidBody>, bodies: BaseRigidBody[]): {
     bodyAIndex: number;
     bodyBIndex: number;
 }[];
+export declare function broadPhaseWithSpatialIndexFiltered(spatialIndex: import("./dynamic-tree").SpatialIndex<RigidBody>, bodies: RigidBody[]): {
+    bodyA: RigidBody;
+    bodyB: RigidBody;
+}[];
+export declare function narrowPhaseWithRigidBodyAndPairs(bodies: RigidBody[], combinationsToCheck: {
+    bodyA: RigidBody;
+    bodyB: RigidBody;
+}[], resolveCollisionFlag: boolean): {
+    contactPoints: Point[];
+    collisions: {
+        bodyA: RigidBody;
+        bodyB: RigidBody;
+        contactPoints: Point[];
+        normal?: Point;
+        depth?: number;
+    }[];
+};

package/dynamic-tree.d.ts

@@ -0,0 +1,57 @@
+import { Point } from "@ue-too/math";
+export interface SpatialIndexObject {
+    AABB: {
+        min: Point;
+        max: Point;
+    };
+}
+export interface SpatialIndex<T extends SpatialIndexObject> {
+    clear(): void;
+    insert(object: T): void;
+    retrieve(object: T): T[];
+    draw?(context: CanvasRenderingContext2D): void;
+}
+export declare class SweepAndPrune<T extends SpatialIndexObject> implements SpatialIndex<T> {
+    private xEndpoints;
+    private objects;
+    private nextId;
+    clear(): void;
+    insert(object: T): void;
+    update(object: T): void;
+    remove(object: T): void;
+    retrieve(queryObject: T): T[];
+    findAllOverlaps(): Array<{
+        a: T;
+        b: T;
+    }>;
+    private insertEndpointSorted;
+    private removeEndpoint;
+    private aabbIntersects;
+    draw?(context: CanvasRenderingContext2D): void;
+    getStats(): {
+        endpointCount: number;
+        objectCount: number;
+    };
+}
+export declare class DynamicTree<T extends SpatialIndexObject> implements SpatialIndex<T> {
+    private root;
+    private nodeCount;
+    private margin;
+    clear(): void;
+    insert(object: T): void;
+    private insertNode;
+    private findBestSibling;
+    private balance;
+    private rotateLeft;
+    private rotateRight;
+    retrieve(object: T): T[];
+    draw(context: CanvasRenderingContext2D): void;
+    private drawNode;
+    private getArea;
+    private combineAABB;
+    private aabbIntersects;
+    getStats(): {
+        nodeCount: number;
+        height: number;
+    };
+}