diff --git a/p2/p2-tests.ts b/p2/p2-tests.ts
new file mode 100644
index 000000000..63c213321
--- /dev/null
+++ b/p2/p2-tests.ts
@@ -0,0 +1,45 @@
+///
+
+// Create a physics world, where bodies and constraints live
+var world = new p2.World({
+ gravity:[0, -9.82]
+});
+
+// Create an empty dynamic body
+var circleBody = new p2.Body({
+ mass: 5,
+ position: [0, 10]
+});
+
+// Add a circle shape to the body.
+var circleShape = new p2.Circle({ radius: 1 });
+circleBody.addShape(circleShape);
+
+// ...and add the body to the world.
+// If we don't add it to the world, it won't be simulated.
+world.addBody(circleBody);
+
+// Create an infinite ground plane.
+var groundBody = new p2.Body({
+ mass: 0 // Setting mass to 0 makes the body static
+});
+var groundShape = new p2.Plane();
+groundBody.addShape(groundShape);
+world.addBody(groundBody);
+
+// To get the trajectories of the bodies,
+// we must step the world forward in time.
+// This is done using a fixed time step size.
+var timeStep = 1 / 60; // seconds
+
+// The "Game loop". Could be replaced by, for example, requestAnimationFrame.
+setInterval(function(){
+
+ // The step method moves the bodies forward in time.
+ world.step(timeStep);
+
+ // Print the circle position to console.
+ // Could be replaced by a render call.
+ console.log("Circle y position: " + circleBody.position[1]);
+
+}, 1000 * timeStep);
diff --git a/p2/p2.d.ts b/p2/p2.d.ts
new file mode 100644
index 000000000..a0e3f8b6a
--- /dev/null
+++ b/p2/p2.d.ts
@@ -0,0 +1,1005 @@
+// Type definitions for p2.js v0.7.1
+// Project: https://github.com/schteppe/p2.js/
+// Definitions by: Clark Stevenson
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module p2 {
+
+ export class AABB {
+
+ constructor(options?: {
+ upperBound?: number[];
+ lowerBound?: number[];
+ });
+
+ setFromPoints(points: number[][], position: number[], angle: number, skinSize: number): void;
+ copy(aabb: AABB): void;
+ extend(aabb: AABB): void;
+ overlaps(aabb: AABB): boolean;
+
+ }
+
+ export class Broadphase {
+
+ static AABB: number;
+ static BOUNDING_CIRCLE: number;
+
+ static NAIVE: number;
+ static SAP: number;
+
+ static boundingRadiusCheck(bodyA: Body, bodyB: Body): boolean;
+ static aabbCheck(bodyA: Body, bodyB: Body): boolean;
+ static canCollide(bodyA: Body, bodyB: Body): boolean;
+
+ constructor(type: number);
+
+ type: number;
+ result: Body[];
+ world: World;
+ boundingVolumeType: number;
+
+ setWorld(world: World): void;
+ getCollisionPairs(world: World): Body[];
+ boundingVolumeCheck(bodyA: Body, bodyB: Body): boolean;
+
+ }
+
+ export class GridBroadphase extends Broadphase {
+
+ constructor(options?: {
+ xmin?: number;
+ xmax?: number;
+ ymin?: number;
+ ymax?: number;
+ nx?: number;
+ ny?: number;
+ });
+
+ xmin: number;
+ xmax: number;
+ ymin: number;
+ ymax: number;
+ nx: number;
+ ny: number;
+ binsizeX: number;
+ binsizeY: number;
+
+ }
+
+ export class NativeBroadphase extends Broadphase {
+
+ }
+
+ export class Narrowphase {
+
+ contactEquations: ContactEquation[];
+ frictionEquations: FrictionEquation[];
+ enableFriction: boolean;
+ enableEquations: boolean;
+ slipForce: number;
+ frictionCoefficient: number;
+ surfaceVelocity: number;
+ reuseObjects: boolean;
+ resuableContactEquations: any[];
+ reusableFrictionEquations: any[];
+ restitution: number;
+ stiffness: number;
+ relaxation: number;
+ frictionStiffness: number;
+ frictionRelaxation: number;
+ enableFrictionReduction: boolean;
+ contactSkinSize: number;
+
+ collidedLastStep(bodyA: Body, bodyB: Body): boolean;
+ reset(): void;
+ createContactEquation(bodyA: Body, bodyB: Body, shapeA: Shape, shapeB: Shape): ContactEquation;
+ createFrictionFromContact(c: ContactEquation): FrictionEquation;
+
+ }
+
+ export class SAPBroadphase extends Broadphase {
+
+ axisList: Body[];
+ axisIndex: number;
+
+ }
+
+ export class Constraint {
+
+ static DISTANCE: number;
+ static GEAR: number;
+ static LOCK: number;
+ static PRISMATIC: number;
+ static REVOLUTE: number;
+
+ constructor(bodyA: Body, bodyB: Body, type: number, options?: {
+ collideConnected?: boolean;
+ wakeUpBodies?: boolean;
+ });
+
+ type: number;
+ equeations: Equation[];
+ bodyA: Body;
+ bodyB: Body;
+ collideConnected: boolean;
+
+ update(): void;
+ setStiffness(stiffness: number): void;
+ setRelaxation(relaxation: number): void;
+
+ }
+
+ export class DistanceConstraint extends Constraint {
+
+ constructor(bodyA: Body, bodyB: Body, type: number, options?: {
+ collideConnected?: boolean;
+ wakeUpBodies?: boolean;
+ distance?: number;
+ localAnchorA?: number[];
+ localAnchorB?: number[];
+ maxForce?: number;
+ });
+
+ localAnchorA: number[];
+ localAnchorB: number[];
+ distance: number;
+ maxForce: number;
+ upperLimitEnabled: boolean;
+ upperLimit: number;
+ lowerLimitEnabled: boolean;
+ lowerLimit: number;
+ position: number;
+
+ setMaxForce(f: number): void;
+ getMaxForce(): number;
+
+ }
+
+ export class GearConstraint extends Constraint {
+
+ constructor(bodyA: Body, bodyB: Body, type: number, options?: {
+ collideConnected?: boolean;
+ wakeUpBodies?: boolean;
+ angle?: number;
+ ratio?: number;
+ maxTorque?: number;
+ });
+
+ ratio: number;
+ angle: number;
+
+ setMaxTorque(torque: number): void;
+ getMaxTorque(): number;
+
+ }
+
+ export class LockConstraint extends Constraint {
+
+ constructor(bodyA: Body, bodyB: Body, type: number, options?: {
+ collideConnected?: boolean;
+ wakeUpBodies?: boolean;
+ localOffsetB?: number[];
+ localAngleB?: number;
+ maxForce?: number;
+ });
+
+ setMaxForce(force: number): void;
+ getMaxForce(): number;
+
+ }
+
+ export class PrismaticConstraint extends Constraint {
+
+ constructor(bodyA: Body, bodyB: Body, type: number, options?: {
+ collideConnected?: boolean;
+ wakeUpBodies?: boolean;
+ maxForce?: number;
+ localAnchorA?: number[];
+ localAnchorB?: number[];
+ localAxisA?: number[];
+ disableRotationalLock?: boolean;
+ upperLimit?: number;
+ lowerLimit?: number;
+ });
+
+ localAnchorA: number[];
+ localAnchorB: number[];
+ localAxisA: number[];
+ position: number;
+ velocity: number;
+ lowerLimitEnabled: boolean;
+ upperLimitEnabled: boolean;
+ lowerLimit: number;
+ upperLimit: number;
+ upperLimitEquation: ContactEquation;
+ lowerLimitEquation: ContactEquation;
+ motorEquation: Equation;
+ motorEnabled: boolean;
+ motorSpeed: number;
+
+ enableMotor(): void;
+ disableMotor(): void;
+ setLimits(lower: number, upper: number): void;
+
+ }
+
+ export class RevoluteConstraint extends Constraint {
+
+ constructor(bodyA: Body, bodyB: Body, type: number, options?: {
+ collideConnected?: boolean;
+ wakeUpBodies?: boolean;
+ worldPivot?: number[];
+ localPivotA?: number[];
+ localPivotB?: number[];
+ maxForce?: number;
+ });
+
+ pivotA: number[];
+ pivotB: number[];
+ motorEquation: RotationalVelocityEquation;
+ motorEnabled: boolean;
+ angle: number;
+ lowerLimitEnabled: boolean;
+ upperLimitEnabled: boolean;
+ lowerLimit: number;
+ upperLimit: number;
+ upperLimitEquation: ContactEquation;
+ lowerLimitEquation: ContactEquation;
+
+ enableMotor(): void;
+ disableMotor(): void;
+ motorIsEnabled(): boolean;
+ setLimits(lower: number, upper: number): void;
+ setMotorSpeed(speed: number): void;
+ getMotorSpeed(): number;
+
+ }
+
+ export class AngleLockEquation extends Equation {
+
+ constructor(bodyA: Body, bodyB: Body, options?: {
+ angle?: number;
+ ratio?: number;
+ });
+
+ computeGq(): number;
+ setRatio(ratio: number): number;
+ setMaxTorque(torque: number): number;
+
+ }
+
+ export class ContactEquation extends Equation {
+
+ constructor(bodyA: Body, bodyB: Body);
+
+ contactPointA: number[];
+ penetrationVec: number[];
+ contactPointB: number[];
+ normalA: number[];
+ restitution: number;
+ firstImpact: boolean;
+ shapeA: Shape;
+ shapeB: Shape;
+
+ computeB(a: number, b: number, h: number): number;
+
+ }
+
+ export class Equation {
+
+ static DEFAULT_STIFFNESS: number;
+ static DEFAULT_RELAXATION: number;
+
+ constructor(bodyA: Body, bodyB: Body, minForce?: number, maxForce?: number);
+
+ minForce: number;
+ maxForce: number;
+ bodyA: Body;
+ bodyB: Body;
+ stiffness: number;
+ relaxation: number;
+ G: number[];
+ offset: number;
+ a: number;
+ b: number;
+ epsilon: number;
+ timeStep: number;
+ needsUpdate: boolean;
+ multiplier: number;
+ relativeVelocity: number;
+ enabled: boolean;
+
+ gmult(G: number[], vi: number[], wi: number[], vj: number[], wj: number[]): number;
+ computeB(a: number, b: number, h: number): number;
+ computeGq(): number;
+ computeGW(): number;
+ computeGWlambda(): number;
+ computeGiMf(): number;
+ computeGiMGt(): number;
+ addToWlambda(deltalambda: number): number;
+ computeInvC(eps: number): number;
+
+ }
+
+ export class FrictionEquation extends Equation {
+
+ constructor(bodyA: Body, bodyB: Body, slipForce: number);
+
+ contactPointA: number[];
+ contactPointB: number[];
+ t: number[];
+ shapeA: Shape;
+ shapeB: Shape;
+ frictionCoefficient: number;
+
+ setSlipForce(slipForce: number): number;
+ getSlipForce(): number;
+ computeB(a: number, b: number, h: number): number;
+
+ }
+
+ export class RotationalLockEquation extends Equation {
+
+ constructor(bodyA: Body, bodyB: Body, options?: {
+ angle?: number;
+ });
+
+ angle: number;
+
+ computeGq(): number;
+
+ }
+
+ export class RotationalVelocityEquation extends Equation {
+
+ constructor(bodyA: Body, bodyB: Body);
+
+ computeB(a: number, b: number, h: number): number;
+
+ }
+
+ export class EventEmitter {
+
+ on(type: string, listener: Function, context: any): EventEmitter;
+ has(type: string, listener: Function): boolean;
+ off(type: string, listener: Function): EventEmitter;
+ emit(event: any): EventEmitter;
+
+ }
+
+ export class ContactMaterialOptions {
+
+ friction: number;
+ restitution: number;
+ stiffness: number;
+ relaxation: number;
+ frictionStiffness: number;
+ frictionRelaxation: number;
+ surfaceVelocity: number;
+
+ }
+
+ export class ContactMaterial {
+
+ static idCounter: number;
+
+ constructor(materialA: Material, materialB: Material, options?: ContactMaterialOptions);
+
+ id: number;
+ materialA: Material;
+ materialB: Material;
+ friction: number;
+ restitution: number;
+ stiffness: number;
+ relaxation: number;
+ frictionStuffness: number;
+ frictionRelaxation: number;
+ surfaceVelocity: number;
+ contactSkinSize: number;
+
+ }
+
+ export class Material {
+
+ static idCounter: number;
+
+ constructor(id: number);
+
+ id: number;
+
+ }
+
+ export class vec2 {
+
+ static crossLength(a: number[], b: number[]): number;
+ static crossVZ(out: number[], vec: number[], zcomp: number): number;
+ static crossZV(out: number[], zcomp: number, vec: number[]): number;
+ static rotate(out: number[], a: number[], angle: number): void;
+ static rotate90cw(out: number[], a: number[]): number;
+ static centroid(out: number[], a: number[], b: number[], c: number[]): number[];
+ static create(): number[];
+ static clone(a: number[]): number[];
+ static fromValues(x: number, y: number): number[];
+ static copy(out: number[], a: number[]): number[];
+ static set(out: number[], x: number, y: number): number[];
+ static toLocalFrame(out: number[], worldPoint: number[], framePosition: number[], frameAngle: number): void;
+ static toGlobalFrame(out: number[], localPoint: number[], framePosition: number[], frameAngle: number): void;
+ static add(out: number[], a: number[], b: number[]): number[];
+ static subtract(out: number[], a: number[], b: number[]): number[];
+ static sub(out: number[], a: number[], b: number[]): number[];
+ static multiply(out: number[], a: number[], b: number[]): number[];
+ static mul(out: number[], a: number[], b: number[]): number[];
+ static divide(out: number[], a: number[], b: number[]): number[];
+ static div(out: number[], a: number[], b: number[]): number[];
+ static scale(out: number[], a: number[], b: number): number[];
+ static distance(a: number[], b: number[]): number;
+ static dist(a: number[], b: number[]): number;
+ static squaredDistance(a: number[], b: number[]): number;
+ static sqrDist(a: number[], b: number[]): number;
+ static length(a: number[]): number;
+ static len(a: number[]): number;
+ static squaredLength(a: number[]): number;
+ static sqrLen(a: number[]): number;
+ static negate(out: number[], a: number[]): number[];
+ static normalize(out: number[], a: number[]): number[];
+ static dot(a: number[], b: number[]): number;
+ static str(a: number[]): string;
+
+ }
+
+ export interface BodyOptions {
+
+ mass?: number;
+ position?: number[];
+ velocity?: number[];
+ angle?: number;
+ angularVelocity?: number;
+ force?: number[];
+ angularForce?: number;
+ fixedRotation?: boolean;
+
+ }
+
+ export class Body extends EventEmitter {
+
+ sleepyEvent: {
+ type: string;
+ };
+
+ sleepEvent: {
+ type: string;
+ };
+
+ wakeUpEvent: {
+ type: string;
+ };
+
+ static DYNAMIC: number;
+ static STATIC: number;
+ static KINEMATIC: number;
+ static AWAKE: number;
+ static SLEEPY: number;
+ static SLEEPING: number;
+
+ constructor(options?: BodyOptions);
+
+ id: number;
+ world: World;
+ shapes: Shape[];
+ mass: number;
+ invMass: number;
+ inertia: number;
+ invInertia: number;
+ invMassSolve: number;
+ invInertiaSolve: number;
+ fixedRotation: number;
+ position: number[];
+ interpolatedPosition: number[];
+ interpolatedAngle: number;
+ previousPosition: number[];
+ previousAngle: number;
+ velocity: number[];
+ vlambda: number[];
+ wlambda: number[];
+ angle: number;
+ angularVelocity: number;
+ force: number[];
+ angularForce: number;
+ damping: number;
+ angularDamping: number;
+ type: number;
+ boundingRadius: number;
+ aabb: AABB;
+ aabbNeedsUpdate: boolean;
+ allowSleep: boolean;
+ wantsToSleep: boolean;
+ sleepState: number;
+ sleepSpeedLimit: number;
+ sleepTimeLimit: number;
+ gravityScale: number;
+ collisionResponse: boolean;
+
+ updateSolveMassProperties(): void;
+ setDensity(density: number): void;
+ getArea(): number;
+ getAABB(): AABB;
+ updateAABB(): void;
+ updateBoundingRadius(): void;
+ addShape(shape: Shape, offset?: number[], angle?: number): void;
+ removeShape(shape: Shape): boolean;
+ updateMassProperties(): void;
+ applyForce(force: number[], worldPoint: number[]): void;
+ toLocalFrame(out: number[], worldPoint: number[]): void;
+ toWorldFrame(out: number[], localPoint: number[]): void;
+ fromPolygon(path: number[][], options?: {
+ optimalDecomp?: boolean;
+ skipSimpleCheck?: boolean;
+ removeCollinearPoints?: any; //boolean | number
+ }): boolean;
+ adjustCenterOfMass(): void;
+ setZeroForce(): void;
+ resetConstraintVelocity(): void;
+ applyDamping(dy: number): void;
+ wakeUp(): void;
+ sleep(): void;
+ sleepTick(time: number, dontSleep: boolean, dt: number): void;
+ getVelocityFromPosition(story: number[], dt: number): number[];
+ getAngularVelocityFromPosition(timeStep: number): number;
+ overlaps(body: Body): boolean;
+
+ }
+
+ export class Spring {
+
+ constructor(bodyA: Body, bodyB: Body, options?: {
+
+ stiffness?: number;
+ damping?: number;
+ localAnchorA?: number[];
+ localAnchorB?: number[];
+ worldAnchorA?: number[];
+ worldAnchorB?: number[];
+
+ });
+
+ stiffness: number;
+ damping: number;
+ bodyA: Body;
+ bodyB: Body;
+
+ applyForce(): void;
+
+ }
+
+ export class LinearSpring extends Spring {
+
+ localAnchorA: number[];
+ localAnchorB: number[];
+ restLength: number;
+
+ setWorldAnchorA(worldAnchorA: number[]): void;
+ setWorldAnchorB(worldAnchorB: number[]): void;
+ getWorldAnchorA(result: number[]): number[];
+ getWorldAnchorB(result: number[]): number[];
+ applyForce(): void;
+
+ }
+
+ export class RotationalSpring extends Spring {
+
+ constructor(bodyA: Body, bodyB: Body, options?: {
+ restAngle?: number;
+ stiffness?: number;
+ damping?: number;
+ });
+
+ restAngle: number;
+
+ }
+
+ export interface CapsuleOptions extends SharedShapeOptions {
+
+ length?: number;
+ radius?: number;
+
+ }
+
+ export class Capsule extends Shape {
+
+ constructor(options?: CapsuleOptions);
+
+ length: number;
+ radius: number;
+
+ }
+
+ export interface CircleOptions extends SharedShapeOptions {
+
+ radius?: number;
+
+ }
+
+ export class Circle extends Shape {
+
+ constructor(options?: CircleOptions);
+
+ radius: number;
+
+ }
+
+ export interface ConvexOptions extends SharedShapeOptions {
+
+ length?: number;
+ radius?: number;
+
+ }
+
+ export class Convex extends Shape {
+
+ static triangleArea(a: number[], b: number[], c: number[]): number;
+
+ constructor(options?: ConvexOptions);
+
+ vertices: number[][];
+ axes: number[];
+ centerOfMass: number[];
+ triangles: number[];
+ boundingRadius: number;
+
+ projectOntoLocalAxis(localAxis: number[], result: number[]): void;
+ projectOntoWorldAxis(localAxis: number[], shapeOffset: number[], shapeAngle: number, result: number[]): void;
+
+ updateCenterOfMass(): void;
+
+ }
+
+ export interface HeightfieldOptions extends SharedShapeOptions {
+
+ heights?: number[];
+ minValue?: number;
+ maxValue?: number;
+ elementWidth?: number;
+
+ }
+
+ export class Heightfield extends Shape {
+
+ constructor(options?: HeightfieldOptions);
+
+ data: number[];
+ maxValue: number;
+ minValue: number;
+ elementWidth: number;
+
+ }
+
+ export interface SharedShapeOptions {
+
+ position?: number[];
+ angle?: number;
+ collisionGroup?: number;
+ collisionResponse?: boolean;
+ collisionMask?: number;
+ sensor?: boolean;
+
+ }
+
+ export interface ShapeOptions extends SharedShapeOptions {
+
+ type?: number;
+
+ }
+
+ export class Shape {
+
+ static idCounter: number;
+ static CIRCLE: number;
+ static PARTICLE: number;
+ static PLANE: number;
+ static CONVEX: number;
+ static LINE: number;
+ static BOX: number;
+ static CAPSULE: number;
+ static HEIGHTFIELD: number;
+
+ constructor(options?: ShapeOptions);
+
+ type: number;
+ id: number;
+ position: number[];
+ angle: number;
+ boundingRadius: number;
+ collisionGroup: number;
+ collisionResponse: boolean;
+ collisionMask: number;
+ material: Material;
+ area: number;
+ sensor: boolean;
+
+ computeMomentOfInertia(mass: number): number;
+ updateBoundingRadius(): number;
+ updateArea(): void;
+ computeAABB(out: AABB, position: number[], angle: number): void;
+
+ }
+
+ export interface LineOptions extends SharedShapeOptions {
+
+ length?: number;
+
+ }
+
+ export class Line extends Shape {
+
+ constructor(options?: LineOptions);
+
+ length: number;
+
+ }
+
+ export class Particle extends Shape {
+
+ constructor(options?: SharedShapeOptions);
+
+ }
+
+ export class Plane extends Shape {
+
+ constructor(options?: SharedShapeOptions);
+
+ }
+
+ export interface BoxOptions {
+
+ width?: number;
+ height?: number;
+
+ }
+
+ export class Box extends Shape {
+
+ constructor(options?: BoxOptions);
+
+ width: number;
+ height: number;
+
+ }
+
+ export class Solver extends EventEmitter {
+
+ static GS: number;
+ static ISLAND: number;
+
+ constructor(options?: {}, type?: number);
+
+ type: number;
+ equations: Equation[];
+ equationSortFunction: Equation; //Equation | boolean
+
+ solve(dy: number, world: World): void;
+ solveIsland(dy: number, island: Island): void;
+ sortEquations(): void;
+ addEquation(eq: Equation): void;
+ addEquations(eqs: Equation[]): void;
+ removeEquation(eq: Equation): void;
+ removeAllEquations(): void;
+
+ }
+
+ export class GSSolver extends Solver {
+
+ constructor(options?: {
+ iterations?: number;
+ tolerance?: number;
+ });
+
+ iterations: number;
+ tolerance: number;
+ useZeroRHS: boolean;
+ frictionIterations: number;
+ usedIterations: number;
+
+ solve(h: number, world: World): void;
+
+ }
+
+ export class OverlapKeeper {
+
+ constructor(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Shape);
+
+ shapeA: Shape;
+ shapeB: Shape;
+ bodyA: Body;
+ bodyB: Body;
+
+ tick(): void;
+ setOverlapping(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Body): void;
+ bodiesAreOverlapping(bodyA: Body, bodyB: Body): boolean;
+ set(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Shape): void;
+
+ }
+
+ export class TupleDictionary {
+
+ data: number[];
+ keys: number[];
+
+ getKey(id1: number, id2: number): string;
+ getByKey(key: number): number;
+ get(i: number, j: number): number;
+ set(i: number, j: number, value: number): number;
+ reset(): void;
+ copy(dict: TupleDictionary): void;
+
+ }
+
+ export class Utils {
+
+ static appendArray(a: Array, b: Array): Array;
+ static splice(array: Array, index: number, howMany: number): void;
+ static extend(a: any, b: any): void;
+ static defaults(options: any, defaults: any): any;
+
+ }
+
+ export class Island {
+
+ equations: Equation[];
+ bodies: Body[];
+
+ reset(): void;
+ getBodies(result: any): Body[];
+ wantsToSleep(): boolean;
+ sleep(): boolean;
+
+ }
+
+ export class IslandManager extends Solver {
+
+ static getUnvisitedNode(nodes: IslandNode[]): IslandNode; // IslandNode | boolean
+
+ equations: Equation[];
+ islands: Island[];
+ nodes: IslandNode[];
+
+ visit(node: IslandNode, bds: Body[], eqs: Equation[]): void;
+ bfs(root: IslandNode, bds: Body[], eqs: Equation[]): void;
+ split(world: World): Island[];
+
+ }
+
+ export class IslandNode {
+
+ constructor(body: Body);
+
+ body: Body;
+ neighbors: IslandNode[];
+ equations: Equation[];
+ visited: boolean;
+
+ reset(): void;
+
+ }
+
+ export class World extends EventEmitter {
+
+ postStepEvent: {
+ type: string;
+ };
+
+ addBodyEvent: {
+ type: string;
+ };
+
+ removeBodyEvent: {
+ type: string;
+ };
+
+ addSpringEvent: {
+ type: string;
+ };
+
+ impactEvent: {
+ type: string;
+ bodyA: Body;
+ bodyB: Body;
+ shapeA: Shape;
+ shapeB: Shape;
+ contactEquation: ContactEquation;
+ };
+
+ postBroadphaseEvent: {
+ type: string;
+ pairs: Body[];
+ };
+
+ beginContactEvent: {
+ type: string;
+ shapeA: Shape;
+ shapeB: Shape;
+ bodyA: Body;
+ bodyB: Body;
+ contactEquations: ContactEquation[];
+ };
+
+ endContactEvent: {
+ type: string;
+ shapeA: Shape;
+ shapeB: Shape;
+ bodyA: Body;
+ bodyB: Body;
+ };
+
+ preSolveEvent: {
+ type: string;
+ contactEquations: ContactEquation[];
+ frictionEquations: FrictionEquation[];
+ };
+
+ static NO_SLEEPING: number;
+ static BODY_SLEEPING: number;
+ static ISLAND_SLEEPING: number;
+
+ static integrateBody(body: Body, dy: number): void;
+
+ constructor(options?: {
+ solver?: Solver;
+ gravity?: number[];
+ broadphase?: Broadphase;
+ islandSplit?: boolean;
+ doProfiling?: boolean;
+ });
+
+ springs: Spring[];
+ bodies: Body[];
+ solver: Solver;
+ narrowphase: Narrowphase;
+ islandManager: IslandManager;
+ gravity: number[];
+ frictionGravity: number;
+ useWorldGravityAsFrictionGravity: boolean;
+ useFrictionGravityOnZeroGravity: boolean;
+ doProfiling: boolean;
+ lastStepTime: number;
+ broadphase: Broadphase;
+ constraints: Constraint[];
+ defaultMaterial: Material;
+ defaultContactMaterial: ContactMaterial;
+ lastTimeStep: number;
+ applySpringForces: boolean;
+ applyDamping: boolean;
+ applyGravity: boolean;
+ solveConstraints: boolean;
+ contactMaterials: ContactMaterial[];
+ time: number;
+ stepping: boolean;
+ islandSplit: boolean;
+ emitImpactEvent: boolean;
+ sleepMode: number;
+
+ addConstraint(c: Constraint): void;
+ addContactMaterial(contactMaterial: ContactMaterial): void;
+ removeContactMaterial(cm: ContactMaterial): void;
+ getContactMaterial(materialA: Material, materialB: Material): ContactMaterial; // ContactMaterial | boolean
+ removeConstraint(c: Constraint): void;
+ step(dy: number, timeSinceLastCalled?: number, maxSubSteps?: number): void;
+ runNarrowphase(np: Narrowphase, bi: Body, si: Shape, xi: any[], ai: number, bj: Body, sj: Shape, xj: any[], aj: number, cm: number, glen: number): void;
+ addSpring(s: Spring): void;
+ removeSpring(s: Spring): void;
+ addBody(body: Body): void;
+ removeBody(body: Body): void;
+ getBodyByID(id: number): Body; //Body | boolean
+ disableBodyCollision(bodyA: Body, bodyB: Body): void;
+ enableBodyCollision(bodyA: Body, bodyB: Body): void;
+ clear(): void;
+ clone(): World;
+ hitTest(worldPoint: number[], bodies: Body[], precision: number): Body[];
+ setGlobalEquationParameters(parameters: {
+ relaxation?: number;
+ stiffness?: number;
+ }): void;
+ setGlobalStiffness(stiffness: number): void;
+ setGlobalRelaxation(relaxation: number): void;
+ }
+
+}