// Type definitions for cannon 0.1 // Project: https://github.com/clark-stevenson/cannon.d.ts // Definitions by: Clark Stevenson // Grzegorz Rozdzialik // Sean Bradley // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // @ts-ignore declare namespace CANNONJS { export interface IAABBOptions { upperBound?: Vec3 | undefined lowerBound?: Vec3 | undefined } export class AABB { lowerBound: Vec3 upperBound: Vec3 constructor(options?: IAABBOptions) clone(): AABB copy(aabb: AABB): void extend(aabb: AABB): void getCorners(a: Vec3, b: Vec3, c: Vec3, d: Vec3, e: Vec3, f: Vec3, g: Vec3, h: Vec3): void overlaps(aabb: AABB): boolean setFromPoints(points: Vec3[], position?: Vec3, quaternion?: Quaternion, skinSize?: number): AABB toLocalFrame(frame: Transform, target: AABB): AABB toWorldFrame(frame: Transform, target: AABB): AABB } export class ArrayCollisionMatrix { matrix: Mat3[] get(i: number, j: number): number set(i: number, j: number, value: number): void reset(): void setNumObjects(n: number): void } export class BroadPhase { world: World useBoundingBoxes: boolean dirty: boolean collisionPairs(world: World, p1: Body[], p2: Body[]): void needBroadphaseCollision(bodyA: Body, bodyB: Body): boolean intersectionTest(bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void doBoundingSphereBroadphase(bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void doBoundingBoxBroadphase(bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void makePairsUnique(pairs1: Body[], pairs2: Body[]): void setWorld(world: World): void boundingSphereCheck(bodyA: Body, bodyB: Body): boolean aabbQuery(world: World, aabb: AABB, result: Body[]): Body[] } export class GridBroadphase extends BroadPhase { nx: number ny: number nz: number aabbMin: Vec3 aabbMax: Vec3 bins: any[] constructor(aabbMin?: Vec3, aabbMax?: Vec3, nx?: number, ny?: number, nz?: number) } export class NaiveBroadphase extends BroadPhase {} export class ObjectCollisionMatrix { matrix: number[] get(i: number, j: number): number set(i: number, j: number, value: number): void reset(): void setNumObjects(n: number): void } export class Ray { from: Vec3 to: Vec3 precision: number checkCollisionResponse: boolean constructor(from?: Vec3, to?: Vec3) getAABB(result: RaycastResult): void } export class RaycastResult { rayFromWorld: Vec3 rayToWorld: Vec3 hitNormalWorld: Vec3 hitPointWorld: Vec3 hasHit: boolean shape: Shape body: Body distance: number reset(): void set( rayFromWorld: Vec3, rayToWorld: Vec3, hitNormalWorld: Vec3, hitPointWorld: Vec3, shape: Shape, body: Body, distance: number ): void } export class SAPBroadphase extends BroadPhase { static insertionSortX(a: any[]): any[] static insertionSortY(a: any[]): any[] static insertionSortZ(a: any[]): any[] static checkBounds(bi: Body, bj: Body, axisIndex?: number): boolean axisList: any[] world: World axisIndex: number constructor(world?: World) autoDetectAxis(): void aabbQuery(world: World, aabb: AABB, result?: Body[]): Body[] } export interface IConstraintOptions { collideConnected?: boolean | undefined wakeUpBodies?: boolean | undefined } export class Constraint { equations: any[] bodyA: Body bodyB: Body id: number collideConnected: boolean constructor(bodyA: Body, bodyB: Body, options?: IConstraintOptions) update(): void disable(): void enable(): void } export class DistanceConstraint extends Constraint { constructor(bodyA: Body, bodyB: Body, distance: number, maxForce?: number) } export interface IHingeConstraintOptions { pivotA?: Vec3 | undefined axisA?: Vec3 | undefined pivotB?: Vec3 | undefined axisB?: Vec3 | undefined maxForce?: number | undefined } export class HingeConstraint extends Constraint { motorEnabled: boolean motorTargetVelocity: number motorMinForce: number motorMaxForce: number motorEquation: RotationalMotorEquation axisA: Vec3 axisB: Vec3 constructor(bodyA: Body, bodyB: Body, options?: IHingeConstraintOptions) enableMotor(): void disableMotor(): void setMotorSpeed(speed: number): void } export class PointToPointConstraint extends Constraint { constructor(bodyA: Body, pivotA: Vec3, bodyB: Body, pivotB: Vec3, maxForce?: number) } export interface ILockConstraintOptions { maxForce?: number | undefined } export class LockConstraint extends Constraint { constructor(bodyA: Body, bodyB: Body, options?: ILockConstraintOptions) } export interface IConeTwistConstraintOptions { pivotA?: Vec3 | undefined pivotB?: Vec3 | undefined axisA?: Vec3 | undefined axisB?: Vec3 | undefined maxForce?: number | undefined } export class ConeTwistConstraint extends Constraint { constructor(bodyA: Body, bodyB: Body, options?: IConeTwistConstraintOptions) } export class Equation { id: number minForce: number maxForce: number bi: Body bj: Body a: number b: number eps: number jacobianElementA: JacobianElement jacobianElementB: JacobianElement enabled: boolean constructor(bi: Body, bj: Body, minForce?: number, maxForce?: number) setSpookParams(stiffness: number, relaxation: number, timeStep: number): void computeB(a: number, b: number, h: number): number computeGq(): number computeGW(): number computeGWlamda(): number computeGiMf(): number computeGiMGt(): number addToWlamda(deltalambda: number): number computeC(): number } export class FrictionEquation extends Equation { constructor(bi: Body, bj: Body, slipForce: number) } export class RotationalEquation extends Equation { ni: Vec3 nj: Vec3 nixnj: Vec3 njxni: Vec3 invIi: Mat3 invIj: Mat3 relVel: Vec3 relForce: Vec3 constructor(bodyA: Body, bodyB: Body) } export class RotationalMotorEquation extends Equation { axisA: Vec3 axisB: Vec3 invLi: Mat3 invIj: Mat3 targetVelocity: number constructor(bodyA: Body, bodyB: Body, maxForce?: number) } export class ContactEquation extends Equation { restitution: number ri: Vec3 rj: Vec3 penetrationVec: Vec3 ni: Vec3 rixn: Vec3 rjxn: Vec3 invIi: Mat3 invIj: Mat3 biInvInertiaTimesRixn: Vec3 bjInvInertiaTimesRjxn: Vec3 constructor(bi: Body, bj: Body) } export interface IContactMaterialOptions { friction?: number | undefined restitution?: number | undefined contactEquationStiffness?: number | undefined contactEquationRelaxation?: number | undefined frictionEquationStiffness?: number | undefined frictionEquationRelaxation?: number | undefined } export class ContactMaterial { id: number materials: Material[] friction: number restitution: number contactEquationStiffness: number contactEquationRelaxation: number frictionEquationStiffness: number frictionEquationRelaxation: number constructor(m1: Material, m2: Material, options?: IContactMaterialOptions) } export class Material { name: string id: number friction: number restitution: number constructor(name: string) } export class JacobianElement { spatial: Vec3 rotational: Vec3 multiplyElement(element: JacobianElement): number multiplyVectors(spacial: Vec3, rotational: Vec3): number } export class Mat3 { constructor(elements?: number[]) identity(): void setZero(): void setTrace(vec3: Vec3): void getTrace(target: Vec3): void vmult(v: Vec3, target?: Vec3): Vec3 smult(s: number): void mmult(m: Mat3): Mat3 scale(v: Vec3, target?: Mat3): Mat3 solve(b: Vec3, target?: Vec3): Vec3 e(row: number, column: number, value?: number): number copy(source: Mat3): Mat3 toString(): string reverse(target?: Mat3): Mat3 setRotationFromQuaternion(q: Quaternion): Mat3 transpose(target?: Mat3): Mat3 } export class Quaternion { x: number y: number z: number w: number constructor(x?: number, y?: number, z?: number, w?: number) set(x: number, y: number, z: number, w: number): void toString(): string toArray(): number[] setFromAxisAngle(axis: Vec3, angle: number): void toAxisAngle(targetAxis?: Vec3): any[] setFromVectors(u: Vec3, v: Vec3): void mult(q: Quaternion, target?: Quaternion): Quaternion inverse(target?: Quaternion): Quaternion conjugate(target?: Quaternion): Quaternion normalize(): void normalizeFast(): void vmult(v: Vec3, target?: Vec3): Vec3 copy(source: Quaternion): Quaternion toEuler(target: Vec3, order?: string): void setFromEuler(x: number, y: number, z: number, order?: string): Quaternion clone(): Quaternion } export class Transform { static pointToLocalFrame(position: Vec3, quaternion: Quaternion, worldPoint: Vec3, result?: Vec3): Vec3 static pointToWorldFrame(position: Vec3, quaternion: Quaternion, localPoint: Vec3, result?: Vec3): Vec3 position: Vec3 quaternion: Quaternion vectorToWorldFrame(localVector: Vec3, result?: Vec3): Vec3 vectorToLocalFrame(position: Vec3, quaternion: Quaternion, worldVector: Vec3, result?: Vec3): Vec3 } export class Vec3 { static ZERO: Vec3 x: number y: number z: number constructor(x?: number, y?: number, z?: number) cross(v: Vec3, target?: Vec3): Vec3 set(x: number, y: number, z: number): Vec3 setZero(): void vadd(v: Vec3, target?: Vec3): Vec3 vsub(v: Vec3, target?: Vec3): Vec3 crossmat(): Mat3 normalize(): number unit(target?: Vec3): Vec3 norm(): number norm2(): number distanceTo(p: Vec3): number mult(scalar: number, target?: Vec3): Vec3 scale(scalar: number, target?: Vec3): Vec3 dot(v: Vec3): number isZero(): boolean negate(target?: Vec3): Vec3 tangents(t1: Vec3, t2: Vec3): void toString(): string toArray(): number[] copy(source: Vec3): Vec3 lerp(v: Vec3, t: number, target?: Vec3): void almostEquals(v: Vec3, precision?: number): boolean almostZero(precision?: number): boolean isAntiparallelTo(v: Vec3, prescision?: number): boolean clone(): Vec3 } export interface IBodyOptions { position?: Vec3 | undefined velocity?: Vec3 | undefined angularVelocity?: Vec3 | undefined quaternion?: Quaternion | undefined mass?: number | undefined material?: Material | undefined type?: number | undefined linearDamping?: number | undefined angularDamping?: number | undefined allowSleep?: boolean | undefined sleepSpeedLimit?: number | undefined sleepTimeLimit?: number | undefined collisionFilterGroup?: number | undefined collisionFilterMask?: number | undefined fixedRotation?: boolean | undefined shape?: Shape | undefined } export class Body extends EventTarget { static DYNAMIC: number static STATIC: number static KINEMATIC: number static AWAKE: number static SLEEPY: number static SLEEPING: number static sleepyEvent: IEvent static sleepEvent: IEvent id: number world: World preStep: Function postStep: Function vlambda: Vec3 collisionFilterGroup: number collisionFilterMask: number collisionResponse: boolean position: Vec3 previousPosition: Vec3 initPosition: Vec3 velocity: Vec3 initVelocity: Vec3 force: Vec3 mass: number invMass: number material: Material linearDamping: number type: number allowSleep: boolean sleepState: number sleepSpeedLimit: number sleepTimeLimit: number timeLastSleepy: number torque: Vec3 quaternion: Quaternion initQuaternion: Quaternion angularVelocity: Vec3 initAngularVelocity: Vec3 interpolatedPosition: Vec3 interpolatedQuaternion: Quaternion shapes: Shape[] shapeOffsets: any[] shapeOrientations: any[] inertia: Vec3 invInertia: Vec3 invInertiaWorld: Mat3 invMassSolve: number invInertiaSolve: Vec3 invInteriaWorldSolve: Mat3 fixedRotation: boolean angularDamping: number aabb: AABB aabbNeedsUpdate: boolean wlambda: Vec3 constructor(options?: IBodyOptions) wakeUp(): void sleep(): void sleepTick(time: number): void updateSolveMassProperties(): void pointToLocalFrame(worldPoint: Vec3, result?: Vec3): Vec3 pointToWorldFrame(localPoint: Vec3, result?: Vec3): Vec3 vectorToWorldFrame(localVector: Vec3, result?: Vec3): Vec3 addShape(shape: Shape, offset?: Vec3, orientation?: Quaternion): void updateBoundingRadius(): void computeAABB(): void updateInertiaWorld(force: Vec3): void applyForce(force: Vec3, worldPoint: Vec3): void applyImpulse(impulse: Vec3, worldPoint: Vec3): void applyLocalForce(force: Vec3, localPoint: Vec3): void applyLocalImpulse(impulse: Vec3, localPoint: Vec3): void updateMassProperties(): void getVelocityAtWorldPoint(worldPoint: Vec3, result: Vec3): Vec3 } export interface IRaycastVehicleOptions { chassisBody?: Body | undefined indexRightAxis?: number | undefined indexLeftAxis?: number | undefined indexUpAxis?: number | undefined } export interface IWheelInfoOptions { chassisConnectionPointLocal?: Vec3 | undefined chassisConnectionPointWorld?: Vec3 | undefined directionLocal?: Vec3 | undefined directionWorld?: Vec3 | undefined axleLocal?: Vec3 | undefined axleWorld?: Vec3 | undefined suspensionRestLength?: number | undefined suspensionMaxLength?: number | undefined radius?: number | undefined suspensionStiffness?: number | undefined dampingCompression?: number | undefined dampingRelaxation?: number | undefined frictionSlip?: number | undefined steering?: number | undefined rotation?: number | undefined deltaRotation?: number | undefined rollInfluence?: number | undefined maxSuspensionForce?: number | undefined isFronmtWheel?: boolean | undefined clippedInvContactDotSuspension?: number | undefined suspensionRelativeVelocity?: number | undefined suspensionForce?: number | undefined skidInfo?: number | undefined suspensionLength?: number | undefined maxSuspensionTravel?: number | undefined useCustomSlidingRotationalSpeed?: boolean | undefined customSlidingRotationalSpeed?: number | undefined position?: Vec3 | undefined direction?: Vec3 | undefined axis?: Vec3 | undefined body?: Body | undefined } export class WheelInfo { maxSuspensionTravbel: number customSlidingRotationalSpeed: number useCustomSlidingRotationalSpeed: boolean sliding: boolean chassisConnectionPointLocal: Vec3 chassisConnectionPointWorld: Vec3 directionLocal: Vec3 directionWorld: Vec3 axleLocal: Vec3 axleWorld: Vec3 suspensionRestLength: number suspensionMaxLength: number radius: number suspensionStiffness: number dampingCompression: number dampingRelaxation: number frictionSlip: number steering: number rotation: number deltaRotation: number rollInfluence: number maxSuspensionForce: number engineForce: number brake: number isFrontWheel: boolean clippedInvContactDotSuspension: number suspensionRelativeVelocity: number suspensionForce: number skidInfo: number suspensionLength: number sideImpulse: number forwardImpulse: number raycastResult: RaycastResult worldTransform: Transform isInContact: boolean constructor(options?: IWheelInfoOptions) } export class RaycastVehicle { chassisBody: Body wheelInfos: IWheelInfoOptions[] sliding: boolean world: World iindexRightAxis: number indexForwardAxis: number indexUpAxis: number constructor(options?: IRaycastVehicleOptions) addWheel(options?: IWheelInfoOptions): void setSteeringValue(value: number, wheelIndex: number): void applyEngineForce(value: number, wheelIndex: number): void setBrake(brake: number, wheelIndex: number): void addToWorld(world: World): void getVehicleAxisWorld(axisIndex: number, result: Vec3): Vec3 updateVehicle(timeStep: number): void updateSuspension(deltaTime: number): void updateWheelTransform(wheelIndex: number): void removeFromWorld(world: World): void getWheelTransformWorld(wheelIndex: number): Transform } export interface IRigidVehicleOptions { chassisBody: Body } export class RigidVehicle { wheelBodies: Body[] coordinateSystem: Vec3 chassisBody: Body constraints: Constraint[] wheelAxes: Vec3[] wheelForces: Vec3[] constructor(options?: IRigidVehicleOptions) addWheel(options?: IWheelInfoOptions): Body setSteeringValue(value: number, wheelIndex: number): void setMotorSpeed(value: number, wheelIndex: number): void disableMotor(wheelIndex: number): void setWheelForce(value: number, wheelIndex: number): void applyWheelForce(value: number, wheelIndex: number): void addToWorld(world: World): void removeFromWorld(world: World): void getWheelSpeed(wheelIndex: number): number } export class SPHSystem { particles: Particle[] density: number smoothingRadius: number speedOfSound: number viscosity: number eps: number pressures: number[] densities: number[] neighbors: number[] add(particle: Particle): void remove(particle: Particle): void getNeighbors(particle: Particle, neighbors: Particle[]): void update(): void w(r: number): number gradw(rVec: Vec3, resultVec: Vec3): void nablaw(r: number): number } export interface ISpringOptions { restLength?: number | undefined stiffness?: number | undefined damping?: number | undefined worldAnchorA?: Vec3 | undefined worldAnchorB?: Vec3 | undefined localAnchorA?: Vec3 | undefined localAnchorB?: Vec3 | undefined } export class Spring { restLength: number stffness: number damping: number bodyA: Body bodyB: Body localAnchorA: Vec3 localAnchorB: Vec3 constructor(options?: ISpringOptions) setWorldAnchorA(worldAnchorA: Vec3): void setWorldAnchorB(worldAnchorB: Vec3): void getWorldAnchorA(result: Vec3): void getWorldAnchorB(result: Vec3): void applyForce(): void } export class Box extends Shape { static calculateInertia(halfExtents: Vec3, mass: number, target: Vec3): void boundingSphereRadius: number collisionResponse: boolean halfExtents: Vec3 convexPolyhedronRepresentation: ConvexPolyhedron constructor(halfExtents: Vec3) updateConvexPolyhedronRepresentation(): void calculateLocalInertia(mass: number, target?: Vec3): Vec3 getSideNormals(sixTargetVectors: boolean, quat?: Quaternion): Vec3[] updateBoundingSphereRadius(): number volume(): number forEachWorldCorner(pos: Vec3, quat: Quaternion, callback: Function): void } export class ConvexPolyhedron extends Shape { static computeNormal(va: Vec3, vb: Vec3, vc: Vec3, target: Vec3): void static project(hull: ConvexPolyhedron, axis: Vec3, pos: Vec3, quat: Quaternion, result: number[]): void vertices: Vec3[] worldVertices: Vec3[] worldVerticesNeedsUpdate: boolean faces: number[][] faceNormals: Vec3[] uniqueEdges: Vec3[] constructor(points?: Vec3[], faces?: number[][]) computeEdges(): void computeNormals(): void getFaceNormal(i: number, target: Vec3): Vec3 clipAgainstHull( posA: Vec3, quatA: Quaternion, hullB: Vec3, quatB: Quaternion, separatingNormal: Vec3, minDist: number, maxDist: number, result: any[] ): void findSaparatingAxis( hullB: ConvexPolyhedron, posA: Vec3, quatA: Quaternion, posB: Vec3, quatB: Quaternion, target: Vec3, faceListA: any[], faceListB: any[] ): boolean testSepAxis( axis: Vec3, hullB: ConvexPolyhedron, posA: Vec3, quatA: Quaternion, posB: Vec3, quatB: Quaternion ): number getPlaneConstantOfFace(face_i: number): number clipFaceAgainstHull( separatingNormal: Vec3, posA: Vec3, quatA: Quaternion, worldVertsB1: Vec3[], minDist: number, maxDist: number, result: any[] ): void clipFaceAgainstPlane( inVertices: Vec3[], outVertices: Vec3[], planeNormal: Vec3, planeConstant: number ): Vec3 computeWorldVertices(position: Vec3, quat: Quaternion): void computeLocalAABB(aabbmin: Vec3, aabbmax: Vec3): void computeWorldFaceNormals(quat: Quaternion): void calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void getAveragePointLocal(target: Vec3): Vec3 transformAllPoints(offset: Vec3, quat: Quaternion): void pointIsInside(p: Vec3): boolean } export class Cylinder extends Shape { constructor(radiusTop: number, radiusBottom: number, height: number, numSegments: number) } export interface IHightfield { minValue?: number | undefined maxValue?: number | undefined elementSize: number } export class Heightfield extends Shape { data: number[][] maxValue: number minValue: number elementSize: number cacheEnabled: boolean pillarConvex: ConvexPolyhedron pillarOffset: Vec3 type: number constructor(data: number[], options?: IHightfield) update(): void updateMinValue(): void updateMaxValue(): void setHeightValueAtIndex(xi: number, yi: number, value: number): void getRectMinMax(iMinX: number, iMinY: number, iMaxX: number, iMaxY: number, result: any[]): void getIndexOfPosition(x: number, y: number, result: any[], clamp: boolean): boolean getConvexTrianglePillar(xi: number, yi: number, getUpperTriangle: boolean): void } export class Particle extends Shape {} export class Plane extends Shape { worldNormal: Vec3 worldNormalNeedsUpdate: boolean boundingSphereRadius: number computeWorldNormal(quat: Quaternion): void calculateWorldAABB(pos: Vec3, quat: Quaternion, min: number, max: number): void } export class Trimesh extends Shape { vertices: number[] indices: number[] scale: Vec3 constructor(vertices: number[], indices: number[]) updateTree(): void getTrianglesInAABB(aabb: AABB, result: number[]): number[] setScale(scale: Vec3): void updateNormals(): void updateEdges(): void getEdgeVertex(edgeIndex: number, firstOrSecond: 0 | 1, vertexStore: Vec3): void getEdgeVector(edgeIndex: number, vectorStore: Vec3): void static computeNormal(va: Vec3, vb: Vec3, vc: Vec3, target: Vec3): void getVertex(i: number, out: Vec3): Vec3 getWorldVertex(i: number, pos: Vec3, quat: Quaternion, out: Vec3): Vec3 getTriangleVertices(i: number, a: Vec3, b: Vec3, c: Vec3): void getNormal(i: number, target: Vec3): Vec3 calculateLocalInertia(mass: number, target: Vec3): Vec3 computeLocalAABB(aabb: Vec3): void updateAABB(): void updateBoundingSphereRadius(): number calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void volume(): number createTorus( radius: number, tube: number, radialSegments: number, tubularSegments: number, arc: number ): Trimesh } export class Shape { static types: { SPHERE: number PLANE: number BOX: number COMPOUND: number CONVEXPOLYHEDRON: number HEIGHTFIELD: number PARTICLE: number CYLINDER: number TRIMESH: number } type: number boundingSphereRadius: number collisionResponse: boolean id: number updateBoundingSphereRadius(): number volume(): number calculateLocalInertia(mass: number, target: Vec3): Vec3 } export class Sphere extends Shape { radius: number constructor(radius: number) } export class GSSolver extends Solver { iterations: number tolerance: number solve(dy: number, world: World): number } export class Solver { iterations: number equations: Equation[] solve(dy: number, world: World): number addEquation(eq: Equation): void removeEquation(eq: Equation): void removeAllEquations(): void } export class SplitSolver extends Solver { subsolver: Solver constructor(subsolver: Solver) solve(dy: number, world: World): number } export class EventTarget { addEventListener(type: string, listener: Function): EventTarget hasEventListener(type: string, listener: Function): boolean removeEventListener(type: string, listener: Function): EventTarget dispatchEvent(event: IEvent): IEvent } export class Pool { objects: any[] type: any[] release(): any get(): any constructObject(): any } export class TupleDictionary { data: { keys: any[] } get(i: number, j: number): number set(i: number, j: number, value: number): void reset(): void } export class Utils { static defaults(options?: any, defaults?: any): any } export class Vec3Pool extends Pool { type: any constructObject(): Vec3 } export class NarrowPhase { contactPointPool: Pool[] v3pool: Vec3Pool } export class World extends EventTarget { iterations: number dt: number allowSleep: boolean contacts: ContactEquation[] frictionEquations: FrictionEquation[] quatNormalizeSkip: number quatNormalizeFast: boolean time: number stepnumber: number default_dt: number nextId: number gravity: Vec3 broadphase: NaiveBroadphase bodies: Body[] solver: Solver constraints: Constraint[] narrowPhase: NarrowPhase collisionMatrix: ArrayCollisionMatrix collisionMatrixPrevious: ArrayCollisionMatrix materials: Material[] contactmaterials: ContactMaterial[] contactMaterialTable: TupleDictionary defaultMaterial: Material defaultContactMaterial: ContactMaterial doProfiling: boolean profile: { solve: number makeContactConstraints: number broadphaser: number integrate: number narrowphase: number } subsystems: any[] addBodyEvent: IBodyEvent removeBodyEvent: IBodyEvent getContactMaterial(m1: Material, m2: Material): ContactMaterial numObjects(): number collisionMatrixTick(): void addBody(body: Body): void addConstraint(c: Constraint): void removeConstraint(c: Constraint): void rayTest(from: Vec3, to: Vec3, result: RaycastResult): void remove(body: Body): void addMaterial(m: Material): void addContactMaterial(cmat: ContactMaterial): void step(dy: number, timeSinceLastCalled?: number, maxSubSteps?: number): void } export interface IEvent { type: string } export interface IBodyEvent extends IEvent { body: Body target: Body } export interface ICollisionEvent extends IBodyEvent { contact: any } } declare module 'cannonjs-ccd' { export = CANNONJS }