@cocos/cannon
Version:
A lightweight 3D physics engine written in JavaScript.
1,391 lines (1,099 loc) • 44.4 kB
TypeScript
// tslint:disable:max-line-length
// tslint:disable-next-line:no-namespace
declare namespace CANNON {
interface IAABBOptions {
upperBound?: Vec3;
lowerBound?: Vec3;
}
class AABB {
public lowerBound: Vec3;
public upperBound: Vec3;
constructor (options?: IAABBOptions);
public clone (): AABB;
public copy (aabb: AABB): void;
public extend (aabb: AABB): void;
public getCorners (a: Vec3, b: Vec3, c: Vec3, d: Vec3, e: Vec3, f: Vec3, g: Vec3, h: Vec3): void;
public overlaps (aabb: AABB): boolean;
public setFromPoints (points: Vec3[], position?: Vec3, quaternion?: Quaternion, skinSize?: number): AABB;
public toLocalFrame (frame: Transform, target: AABB): AABB;
public toWorldFrame (frame: Transform, target: AABB): AABB;
}
/**
* @class OctreeNode
* @param {object} [options]
* @param {Octree} [options.root]
* @param {AABB} [options.aabb]
*/
class OctreeNode {
/**
* The root node
* @property {OctreeNode} root
*/
root: OctreeNode | null;
/**
* Boundary of this node
* @property {AABB} aabb
*/
aabb: AABB;
/**
* Contained data at the current node level.
* @property {Array} data
*/
data: number[];
/**
* Children to this node
* @property {Array} children
*/
children: OctreeNode[];
/**
* Insert data into this node
* @method insert
* @param {AABB} aabb
* @param {object} elementData
* @return {boolean} True if successful, otherwise false
*/
insert (aabb: AABB, elementData: any, level?: number | 0): boolean
reset (): void;
/**
* Create 8 equally sized children nodes and put them in the .children array.
* @method subdivide
*/
subdivide (): void;
/**
* Get all data, potentially within an AABB
* @method aabbQuery
* @param {AABB} aabb
* @param {array} result
* @return {array} The "result" object
*/
aabbQuery (aabb: AABB, resul: any[]): any[]
/**
* Get all data, potentially intersected by a ray.
* @method rayQuery
* @param {Ray} ray
* @param {Transform} treeTransform
* @param {array} result
* @return {array} The "result" object
*/
rayQuery (ray: Ray, treeTransform: Transform, result: any[]): any[];
/**
* @method removeEmptyNodes
*/
removeEmptyNodes (): void;
}
/**
* @class Octree
* @param {AABB} aabb The total AABB of the tree
* @param {object} [options]
* @param {number} [options.maxDepth=8]
* @extends OctreeNode
*/
class Octree extends OctreeNode {
maxDepth: number | 8;
constructor (aabb?: AABB, opt?: any);
}
class ArrayCollisionMatrix {
public matrix: Mat3[];
public get (i: number, j: number): number;
public set (i: number, j: number, value: number): void;
public reset (): void;
public setNumObjects (n: number): void;
}
class BroadPhase {
public world: World;
public useBoundingBoxes: boolean;
public dirty: boolean;
public collisionPairs (world: World, p1: Body[], p2: Body[]): void;
public needBroadphaseCollision (bodyA: Body, bodyB: Body): boolean;
public intersectionTest (bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void;
public doBoundingSphereBroadphase (bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void;
public doBoundingBoxBroadphase (bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void;
public makePairsUnique (pairs1: Body[], pairs2: Body[]): void;
public setWorld (world: World): void;
public boundingSphereCheck (bodyA: Body, bodyB: Body): boolean;
public aabbQuery (world: World, aabb: AABB, result: Body[]): Body[];
}
class GridBroadphase extends BroadPhase {
public nx: number;
public ny: number;
public nz: number;
public aabbMin: Vec3;
public aabbMax: Vec3;
public bins: any[];
constructor (aabbMin?: Vec3, aabbMax?: Vec3, nx?: number, ny?: number, nz?: number);
}
class NaiveBroadphase extends BroadPhase {
}
class ObjectCollisionMatrix {
public matrix: number[];
public get (i: number, j: number): number;
public set (i: number, j: number, value: number): void;
public reset (): void;
public setNumObjects (n: number): void;
}
class Ray {
public from: Vec3;
public to: Vec3;
public precision: number;
public checkCollisionResponse: boolean;
constructor (from?: Vec3, to?: Vec3);
public getAABB (result: RaycastResult): void;
}
class RaycastResult {
public rayFromWorld: Vec3;
public rayToWorld: Vec3;
public hitNormalWorld: Vec3;
public hitPointWorld: Vec3;
public hasHit: boolean;
public shape: Shape;
public body: Body;
public distance: number;
public reset (): void;
public set (rayFromWorld: Vec3, rayToWorld: Vec3, hitNormalWorld: Vec3, hitPointWorld: Vec3, shape: Shape, body: Body, distance: number): void;
}
class SAPBroadphase extends BroadPhase {
public static insertionSortX (a: any[]): any[];
public static insertionSortY (a: any[]): any[];
public static insertionSortZ (a: any[]): any[];
public static checkBounds (bi: Body, bj: Body, axisIndex?: number): boolean;
public axisList: any[];
public world: World;
public axisIndex: number;
constructor (world?: World);
public autoDetectAxis (): void;
public aabbQuery (world: World, aabb: AABB, result?: Body[]): Body[];
}
interface IConstraintOptions {
collideConnected?: boolean;
wakeUpBodies?: boolean;
}
class Constraint {
public equations: any[];
public bodyA: Body;
public bodyB: Body;
public id: number;
public collideConnected: boolean;
constructor (bodyA: Body, bodyB: Body, options?: IConstraintOptions);
public update (): void;
public disable (): void;
public enable (): void;
}
class DistanceConstraint extends Constraint {
constructor (bodyA: Body, bodyB: Body, distance: number, maxForce?: number);
}
interface IHingeConstraintOptions {
pivotA?: Vec3;
axisA?: Vec3;
pivotB?: Vec3;
axisB?: Vec3;
maxForce?: number;
}
class HingeConstraint extends PointToPointConstraint {
public motorEnabled: boolean;
public motorTargetVelocity: number;
public motorMinForce: number;
public motorMaxForce: number;
public motorEquation: RotationalMotorEquation;
pivotA: Vec3;
axisA: Vec3;
pivotB: Vec3;
axisB: Vec3;
equations: any[];
constructor (bodyA: Body, bodyB: Body, options?: IHingeConstraintOptions);
public enableMotor (): void;
public disableMotor (): void;
setMotorSpeed (v: number): void;
setMotorMaxForce (v: number): void;
update (): void;
}
class PointToPointConstraint extends Constraint {
constructor (bodyA: Body, pivotA: Vec3 | null, bodyB: Body, pivotB?: Vec3, maxForce?: number);
pivotA: Vec3;
pivotB: Vec3;
equations: ContactEquation[];
}
interface ILockConstraintOptions {
maxForce?: number;
}
class LockConstraint extends Constraint {
constructor (bodyA: Body, bodyB: Body, options?: ILockConstraintOptions);
}
interface IConeTwistConstraintOptions {
pivotA?: Vec3;
pivotB?: Vec3;
axisA?: Vec3;
axisB?: Vec3;
maxForce?: number;
}
class ConeTwistConstraint extends Constraint {
constructor (bodyA: Body, bodyB: Body, options?: IConeTwistConstraintOptions);
}
class Equation {
public readonly id: number;
public minForce: number;
public maxForce: number;
public bi: Body;
public bj: Body;
public a: number;
public b: number;
public eps: number;
public jacobianElementA: JacobianElement;
public jacobianElementB: JacobianElement;
public enabled: boolean;
public multiplier: number;
constructor (bi: Body, bj: Body, minForce?: number, maxForce?: number);
public setSpookParams (stiffness: number, relaxation: number, timeStep: number): void;
public computeB (a: number, b: number, h: number): number;
public computeGq (): number;
public computeGW (): number;
public computeGWlamda (): number;
public computeGiMf (): number;
public computeGiMGt (): number;
public addToWlamda (deltalambda: number): number;
public computeC (): number;
}
class FrictionEquation extends Equation {
constructor (bi: Body, bj: Body, slipForce: number);
}
class RotationalEquation extends Equation {
public ni: Vec3;
public nj: Vec3;
public nixnj: Vec3;
public njxni: Vec3;
public invIi: Mat3;
public invIj: Mat3;
public relVel: Vec3;
public relForce: Vec3;
axisA: Vec3;
axisB: Vec3;
maxAngle: number;
constructor (bodyA: Body, bodyB: Body);
}
class RotationalMotorEquation extends Equation {
public axisA: Vec3;
public axisB: Vec3;
public invLi: Mat3;
public invIj: Mat3;
public targetVelocity: number;
constructor (bodyA: Body, bodyB: Body, maxForce?: number);
}
class ContactEquation extends Equation {
public si: Shape;
public sj: Shape;
public restitution: number;
public ri: Vec3;
public rj: Vec3;
// public penetrationVec: Vec3;
public ni: Vec3;
// public rixn: Vec3;
// public rjxn: Vec3;
// public invIi: Mat3;
// public invIj: Mat3;
// public biInvInertiaTimesRixn: Vec3;
// public bjInvInertiaTimesRjxn: Vec3;
constructor (bi: Body, bj: Body);
}
interface IContactMaterialOptions {
friction?: number;
restitution?: number;
contactEquationStiffness?: number;
contactEquationRelaxation?: number;
frictionEquationStiffness?: number;
frictionEquationRelaxation?: number;
}
class ContactMaterial {
public id: number;
public materials: Material[];
public friction: number;
public restitution: number;
public contactEquationStiffness: number;
public contactEquationRelaxation: number;
public frictionEquationStiffness: number;
public frictionEquationRelaxation: number;
constructor (m1: Material, m2: Material, options?: IContactMaterialOptions);
}
class Material {
public name: string;
public id: number;
public friction: number;
public restitution: number;
constructor (name: string);
}
class JacobianElement {
public spatial: Vec3;
public rotational: Vec3;
public multiplyElement (element: JacobianElement): number;
public multiplyVectors (spacial: Vec3, rotational: Vec3): number;
}
class Mat3 {
constructor (elements?: number[]);
public identity (): void;
public setZero (): void;
public setTrace (vec3: Vec3): void;
public getTrace (target: Vec3): void;
public vmult (v: Vec3, target?: Vec3): Vec3;
public smult (s: number): void;
public mmult (m: Mat3): Mat3;
public scale (v: Vec3, target?: Mat3): Mat3;
public solve (b: Vec3, target?: Vec3): Vec3;
public e (row: number, column: number, value?: number): number;
public copy (source: Mat3): Mat3;
public toString (): string;
public reverse (target?: Mat3): Mat3;
public setRotationFromQuaternion (q: Quaternion): Mat3;
public transpose (target?: Mat3): Mat3;
}
class Quaternion {
public x: number;
public y: number;
public z: number;
public w: number;
constructor (x?: number, y?: number, z?: number, w?: number);
public set (x: number, y: number, z: number, w: number): void;
public toString (): string;
public toArray (): number[];
public setFromAxisAngle (axis: Vec3, angle: number): void;
public toAxisAngle (targetAxis?: Vec3): any[];
public setFromVectors (u: Vec3, v: Vec3): void;
public mult (q: Quaternion, target?: Quaternion): Quaternion;
public inverse (target?: Quaternion): Quaternion;
public conjugate (target?: Quaternion): Quaternion;
public normalize (): void;
public normalizeFast (): void;
public vmult (v: Vec3, target?: Vec3): Vec3;
public copy (source: Quaternion): Quaternion;
public toEuler (target: Vec3, order?: string): void;
public setFromEuler (x: number, y: number, z: number, order?: string): Quaternion;
public clone (): Quaternion;
}
class Transform {
public static pointToLocalFrame (position: Vec3, quaternion: Quaternion, worldPoint: Vec3, result?: Vec3): Vec3;
public static pointToWorldFrame (position: Vec3, quaternion: Quaternion, localPoint: Vec3, result?: Vec3): Vec3;
public position: Vec3;
public quaternion: Quaternion;
public vectorToWorldFrame (localVector: Vec3, result?: Vec3): Vec3;
public vectorToLocalFrame (position: Vec3, quaternion: Quaternion, worldVector: Vec3, result?: Vec3): Vec3;
}
class Vec3 {
public static ZERO: Vec3;
public x: number;
public y: number;
public z: number;
constructor (x?: number, y?: number, z?: number);
public cross (v: Vec3, target?: Vec3): Vec3;
public set (x: number, y: number, z: number): Vec3;
public setZero (): void;
public vadd (v: Vec3, target?: Vec3): Vec3;
public vsub (v: Vec3, target?: Vec3): Vec3;
public crossmat (): Mat3;
public normalize (): number;
public unit (target?: Vec3): Vec3;
public norm (): number;
public length (): number;
public norm2 (): number;
public distanceTo (p: Vec3): number;
public mult (scalar: number, target?: Vec3): Vec3;
public scale (scalar: number, target?: Vec3): Vec3;
public dot (v: Vec3): number;
public isZero (): boolean;
public negate (target?: Vec3): Vec3;
public tangents (t1: Vec3, t2: Vec3): void;
public toString (): string;
public toArray (): number[];
public copy (source: Vec3): Vec3;
public lerp (v: Vec3, t: number, target?: Vec3): void;
public almostEquals (v: Vec3, precision?: number): boolean;
public almostZero (precision?: number): boolean;
public isAntiparallelTo (v: Vec3, prescision?: number): boolean;
public clone (): Vec3;
}
interface IBodyOptions {
position?: Vec3;
velocity?: Vec3;
angularVelocity?: Vec3;
quaternion?: Quaternion;
mass?: number;
material?: Material;
type?: number;
linearDamping?: number;
angularDamping?: number;
allowSleep?: boolean;
sleepSpeedLimit?: number;
sleepTimeLimit?: number;
collisionFilterGroup?: number;
collisionFilterMask?: number;
fixedRotation?: boolean;
useGravity?: boolean;
shape?: Shape;
}
class Body extends EventTarget {
public static DYNAMIC: number;
public static STATIC: number;
public static KINEMATIC: number;
public static AWAKE: number;
public static SLEEPY: number;
public static SLEEPING: number;
public static sleepyEvent: IEvent;
public static sleepEvent: IEvent;
public readonly id: number;
public world: World;
public preStep: Function;
public postStep: Function;
public vlambda: Vec3;
public collisionFilterGroup: number;
public collisionFilterMask: number;
public collisionResponse: boolean;
public position: Vec3;
public previousPosition: Vec3;
public initPosition: Vec3;
public interpolatedPosition: Vec3;
public velocity: Vec3;
public initVelocity: Vec3;
public angularVelocity: Vec3;
public initAngularVelocity: Vec3;
public force: Vec3;
public torque: Vec3;
public mass: number;
public invMass: number;
public material: Material;
public linearDamping: number;
public type: number;
public allowSleep: boolean;
public sleepState: number;
public sleepSpeedLimit: number;
public sleepTimeLimit: number;
public timeLastSleepy: number;
public quaternion: Quaternion;
public previousQuaternion: Quaternion;
public initQuaternion: Quaternion;
public interpolatedQuaternion: Quaternion;
public shapes: Shape[];
public shapeOffsets: any[];
public shapeOrientations: any[];
public inertia: Vec3;
public invInertia: Vec3;
public invInertiaWorld: Mat3;
public invMassSolve: number;
public invInertiaSolve: Vec3;
public invInteriaWorldSolve: Mat3;
public fixedRotation: boolean;
public angularDamping: number;
public aabb: AABB;
public aabbNeedsUpdate: boolean;
public wlambda: Vec3;
public angularFactor: Vec3;
public linearFactor: Vec3;
public useGravity: boolean;
public hasTrigger: boolean;
public ccdSpeedThreshold: number;
public ccdIterations: number;
constructor (options?: IBodyOptions);
public isAwake (): boolean;
public isSleeping (): boolean;
public isSleepy (): boolean;
public wakeUp (): void;
public sleep (): void;
public sleepTick (time: number): void;
public updateSolveMassProperties (): void;
public pointToLocalFrame (worldPoint: Vec3, result?: Vec3): Vec3;
public pointToWorldFrame (localPoint: Vec3, result?: Vec3): Vec3;
public vectorToWorldFrame (localVector: Vec3, result?: Vec3): Vec3;
public addShape (shape: Shape, offset?: Vec3, orientation?: Quaternion): void;
public removeShape (shape: Shape): void;
public updateBoundingRadius (): void;
public computeAABB (): void;
public updateInertiaWorld (force: Vec3): void;
public applyForce (force: Vec3, worldPoint: Vec3): void;
public applyImpulse (impulse: Vec3, worldPoint: Vec3): void;
public applyLocalForce (force: Vec3, localPoint: Vec3): void;
public applyLocalImpulse (impulse: Vec3, localPoint: Vec3): void;
public updateMassProperties (): void;
public getVelocityAtWorldPoint (worldPoint: Vec3, result: Vec3): Vec3;
public updateHasTrigger (): void;
}
interface IRaycastVehicleOptions {
chassisBody?: Body;
indexRightAxis?: number;
indexLeftAxis?: number;
indexUpAxis?: number;
}
interface IWheelInfoOptions {
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;
isFronmtWheel?: boolean;
clippedInvContactDotSuspension?: number;
suspensionRelativeVelocity?: number;
suspensionForce?: number;
skidInfo?: number;
suspensionLength?: number;
maxSuspensionTravel?: number;
useCustomSlidingRotationalSpeed?: boolean;
customSlidingRotationalSpeed?: number;
position?: Vec3;
direction?: Vec3;
axis?: Vec3;
body?: Body;
}
class WheelInfo {
public maxSuspensionTravbel: number;
public customSlidingRotationalSpeed: number;
public useCustomSlidingRotationalSpeed: boolean;
public sliding: boolean;
public chassisConnectionPointLocal: Vec3;
public chassisConnectionPointWorld: Vec3;
public directionLocal: Vec3;
public directionWorld: Vec3;
public axleLocal: Vec3;
public axleWorld: Vec3;
public suspensionRestLength: number;
public suspensionMaxLength: number;
public radius: number;
public suspensionStiffness: number;
public dampingCompression: number;
public dampingRelaxation: number;
public frictionSlip: number;
public steering: number;
public rotation: number;
public deltaRotation: number;
public rollInfluence: number;
public maxSuspensionForce: number;
public engineForce: number;
public brake: number;
public isFrontWheel: boolean;
public clippedInvContactDotSuspension: number;
public suspensionRelativeVelocity: number;
public suspensionForce: number;
public skidInfo: number;
public suspensionLength: number;
public sideImpulse: number;
public forwardImpulse: number;
public raycastResult: RaycastResult;
public worldTransform: Transform;
public isInContact: boolean;
constructor (options?: IWheelInfoOptions);
}
class RaycastVehicle {
public chassisBody: Body;
public wheelInfos: IWheelInfoOptions[];
public sliding: boolean;
public world: World;
public iindexRightAxis: number;
public indexForwardAxis: number;
public indexUpAxis: number;
constructor (options?: IRaycastVehicleOptions);
public addWheel (options?: IWheelInfoOptions): void;
public setSteeringValue (value: number, wheelIndex: number): void;
public applyEngineForce (value: number, wheelIndex: number): void;
public setBrake (brake: number, wheelIndex: number): void;
public addToWorld (world: World): void;
public getVehicleAxisWorld (axisIndex: number, result: Vec3): Vec3;
public updateVehicle (timeStep: number): void;
public updateSuspension (deltaTime: number): void;
public removeFromWorld (world: World): void;
public getWheelTransformWorld (wheelIndex: number): Transform;
}
interface IRigidVehicleOptions {
chassisBody: Body;
}
class RigidVehicle {
public wheelBodies: Body[];
public coordinateSystem: Vec3;
public chassisBody: Body;
public constraints: Constraint[];
public wheelAxes: Vec3[];
public wheelForces: Vec3[];
constructor (options?: IRigidVehicleOptions);
public addWheel (options?: IWheelInfoOptions): Body;
public setSteeringValue (value: number, wheelIndex: number): void;
public setMotorSpeed (value: number, wheelIndex: number): void;
public disableMotor (wheelIndex: number): void;
public setWheelForce (value: number, wheelIndex: number): void;
public applyWheelForce (value: number, wheelIndex: number): void;
public addToWorld (world: World): void;
public removeFromWorld (world: World): void;
public getWheelSpeed (wheelIndex: number): number;
}
class SPHSystem {
public particles: Particle[];
public density: number;
public smoothingRadius: number;
public speedOfSound: number;
public viscosity: number;
public eps: number;
public pressures: number[];
public densities: number[];
public neighbors: number[];
public add (particle: Particle): void;
public remove (particle: Particle): void;
public getNeighbors (particle: Particle, neighbors: Particle[]): void;
public update (): void;
public w (r: number): number;
public gradw (rVec: Vec3, resultVec: Vec3): void;
public nablaw (r: number): number;
}
interface ISpringOptions {
restLength?: number;
stiffness?: number;
damping?: number;
worldAnchorA?: Vec3;
worldAnchorB?: Vec3;
localAnchorA?: Vec3;
localAnchorB?: Vec3;
}
class Spring {
public restLength: number;
public stffness: number;
public damping: number;
public bodyA: Body;
public bodyB: Body;
public localAnchorA: Vec3;
public localAnchorB: Vec3;
constructor (options?: ISpringOptions);
public setWorldAnchorA (worldAnchorA: Vec3): void;
public setWorldAnchorB (worldAnchorB: Vec3): void;
public getWorldAnchorA (result: Vec3): void;
public getWorldAnchorB (result: Vec3): void;
public applyForce (): void;
}
class Box extends Shape {
public static calculateIntertia (halfExtents: Vec3, mass: number, target: Vec3): void;
public boundingSphereRadius: number;
public collisionResponse: boolean;
public halfExtents: Vec3;
public convexPolyhedronRepresentation: ConvexPolyhedron;
constructor (halfExtents: Vec3);
public updateConvexPolyhedronRepresentation (): void;
public calculateLocalInertia (mass: number, target?: Vec3): Vec3;
public getSideNormals (sixTargetVectors: boolean, quat?: Quaternion): Vec3[];
public updateBoundingSphereRadius (): number;
public volume (): number;
public forEachWorldCorner (pos: Vec3, quat: Quaternion, callback: Function): void;
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
}
class ConvexPolyhedron extends Shape {
public static computeNormal (va: Vec3, vb: Vec3, vc: Vec3, target: Vec3): void;
public static project (hull: ConvexPolyhedron, axis: Vec3, pos: Vec3, quat: Quaternion, result: number[]): void;
public vertices: Vec3[];
public worldVertices: Vec3[];
public worldVerticesNeedsUpdate: boolean;
public worldFaceNormalsNeedsUpdate: boolean;
public faces: number[][];
public faceNormals: Vec3[];
public uniqueEdges: Vec3[];
public uniqueAxes: Vec3[];
constructor (points?: Vec3[], faces?: number[][]);
public computeEdges (): void;
public computeNormals (): void;
public computeWorldFaceNormals (quat: Quaternion): void;
public getFaceNormal (i: number, target: Vec3): Vec3;
public clipAgainstHull (posA: Vec3, quatA: Quaternion, hullB: Vec3, quatB: Quaternion, separatingNormal: Vec3, minDist: number, maxDist: number, result: any[]): void;
public findSaparatingAxis (hullB: ConvexPolyhedron, posA: Vec3, quatA: Quaternion, posB: Vec3, quatB: Quaternion, target: Vec3, faceListA: any[], faceListB: any[]): boolean;
public testSepAxis (axis: Vec3, hullB: ConvexPolyhedron, posA: Vec3, quatA: Quaternion, posB: Vec3, quatB: Quaternion): number;
public getPlaneConstantOfFace (face_i: number): number;
public clipFaceAgainstHull (separatingNormal: Vec3, posA: Vec3, quatA: Quaternion, worldVertsB1: Vec3[], minDist: number, maxDist: number, result: any[]): void;
public clipFaceAgainstPlane (inVertices: Vec3[], outVertices: Vec3[], planeNormal: Vec3, planeConstant: number): Vec3;
public computeWorldVertices (position: Vec3, quat: Quaternion): void;
public computeLocalAABB (aabbmin: Vec3, aabbmax: Vec3): void;
public computeWorldFaceNormals (quat: Quaternion): void;
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
public getAveragePointLocal (target: Vec3): Vec3;
public transformAllPoints (offset: Vec3, quat: Quaternion): void;
public pointIsInside (p: Vec3): boolean;
}
class Cylinder extends ConvexPolyhedron {
constructor (radiusTop: number, radiusBottom: number, height: number, numSegments: number, isDirY?: boolean);
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
}
interface IHightfield {
minValue?: number;
maxValue?: number;
elementSize: number;
}
class Heightfield extends Shape {
public data: number[][];
public maxValue: number;
public minValue: number;
public elementSize: number;
public cacheEnabled: boolean;
public pillarConvex: ConvexPolyhedron;
public pillarOffset: Vec3;
public type: number;
constructor (data: number[][], options?: IHightfield);
public update (): void;
public updateMinValue (): void;
public updateMaxValue (): void;
public setHeightValueAtIndex (xi: number, yi: number, value: number): void;
public getRectMinMax (iMinX: number, iMinY: number, iMaxX: number, iMaxY: number, result: any[]): void;
public getIndexOfPosition (x: number, y: number, result: any[], clamp: boolean): boolean;
public getConvexTrianglePillar (xi: number, yi: number, getUpperTriangle: boolean): void;
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
}
class Particle extends Shape {
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
}
class Plane extends Shape {
public worldNormal: Vec3;
public worldNormalNeedsUpdate: boolean;
public boundingSphereRadius: number;
public computeWorldNormal (quat: Quaternion): void;
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
}
class Shape extends EventTarget {
public static types: {
SPHERE: number;
PLANE: number;
BOX: number;
COMPOUND: number;
CONVEXPOLYHEDRON: number;
HEIGHTFIELD: number;
PARTICLE: number;
CYLINDER: number;
};
public readonly id: number;
public type: number;
public body: Body;
public boundingSphereRadius: number;
public collisionFilterMask: number;
public collisionFilterGroup: number;
public collisionResponse: boolean;
public material: Material;
public updateBoundingSphereRadius (): number;
public volume (): number;
public calculateLocalInertia (mass: number, target: Vec3): Vec3;
/**
* @method calculateWorldAABB
* @param {Vec3} pos
* @param {Quaternion} quat
* @param {Vec3} min
* @param {Vec3} max
* @note only child have implement
*/
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
}
class Sphere extends Shape {
public radius: number;
constructor (radius: number);
}
class Trimesh extends Shape {
/**
* @property vertices
* @type {Array}
*/
public vertices: Float32Array;
/**
* Array of integers, indicating which vertices each triangle consists of. The length of this array is thus 3 times the number of triangles.
* @property indices
* @type {Array}
*/
public indices: Int16Array;
/**
* The normals data.
* @property normals
* @type {Array}
*/
public normals: Float32Array;
/**
* The local AABB of the mesh.
* @property aabb
* @type {Array}
*/
public aabb: AABB;
/**
* References to vertex pairs, making up all unique edges in the trimesh.
* @property {array} edges
*/
public edges: [];
/**
* Local scaling of the mesh. Use .setScale() to set it.
* @property {Vec3} scale
*/
public scale: Vec3;
/**
* The indexed triangles. Use .updateTree() to update it.
* @property {Octree} tree
*/
public tree: Octree;
constructor (vertices: Float32Array, indices: Uint16Array);
public updateTree (): void;
public getTrianglesInAABB (): [];
public setScale (scale: Vec3): void;
/**
* Compute the normals of the faces. Will save in the .normals array.
* @method updateNormals
*/
public updateNormals (): void;
/**
* Update the .edges property
* @method updateEdges
*/
public updateEdges (): void;
/**
* Get an edge vertex
* @method getEdgeVertex
* @param {number} edgeIndex
* @param {number} firstOrSecond 0 or 1, depending on which one of the vertices you need.
* @param {Vec3} vertexStore Where to store the result
*/
public getEdgeVertex (edgeIndex: number, firstOrSecond: number, vertexStore: Vec3): void;
/**
* Get a vector along an edge.
* @method getEdgeVector
* @param {number} edgeIndex
* @param {Vec3} vectorStore
*/
public getEdgeVector (edgeIndex: number, vectorStore: Vec3): void;
/**
* Get vertex i.
* @method getVertex
* @param {number} i
* @param {Vec3} out
* @return {Vec3} The "out" vector object
*/
public getVertex (i: number, out: Vec3): Vec3;
/**
* Get raw vertex i
* @private
* @method _getUnscaledVertex
* @param {number} i
* @param {Vec3} out
* @return {Vec3} The "out" vector object
*/
public _getUnscaledVertex (i: number, out: Vec3): Vec3;
/**
* Get a vertex from the trimesh,transformed by the given position and quaternion.
* @method getWorldVertex
* @param {number} i
* @param {Vec3} pos
* @param {Quaternion} quat
* @param {Vec3} out
* @return {Vec3} The "out" vector object
*/
public getWorldVertex (i: number, pos: Vec3, qua: Quaternion, out: Vec3): Vec3;
/**
* Get the three vertices for triangle i.
* @method getTriangleVertices
* @param {number} i
* @param {Vec3} a
* @param {Vec3} b
* @param {Vec3} c
*/
public getTriangleVertices (i: number, a: Vec3, b: Vec3, c: Vec3): void;
/**
* Compute the normal of triangle i.
* @method getNormal
* @param {Number} i
* @param {Vec3} target
* @return {Vec3} The "target" vector object
*/
public getNormal (i: number, target: Vec3): Vec3;
/**
* @method calculateLocalInertia
* @param {Number} mass
* @param {Vec3} target
* @return {Vec3} The "target" vector object
*/
public calculateLocalInertia (mass: number, target: Vec3): Vec3;
/**
* Compute the local AABB for the trimesh
* @method computeLocalAABB
* @param {AABB} aabb
*/
public computeLocalAABB (aabb: AABB): void;
/**
* Update the .aabb property
* @method updateAABB
*/
public updateAABB (): void;
/**
* @method calculateWorldAABB
* @param {Vec3} pos
* @param {Quaternion} quat
* @param {Vec3} min
* @param {Vec3} max
*/
public calculateWorldAABB (pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
/**
* Get approximate volume
* @method volume
* @return {Number}
*/
public volume (): number;
/**
* Get face normal given 3 vertices
* @static
* @method computeNormal
* @param {Vec3} va
* @param {Vec3} vb
* @param {Vec3} vc
* @param {Vec3} target
*/
public static computeNormal (va: Vec3, vb: Vec3, vc: Vec3, target: Vec3): void;
/**
* Create a Trimesh instance, shaped as a torus.
* @static
* @method createTorus
* @param {number} [radius=1]
* @param {number} [tube=0.5]
* @param {number} [radialSegments=8]
* @param {number} [tubularSegments=6]
* @param {number} [arc=6.283185307179586]
* @return {Trimesh} A torus
*/
public static createTorus (radius: number, tube: number, radialSegments: number, tubularSegments: number, arc: number): Trimesh;
}
class GSSolver extends Solver {
public iterations: number;
public tolerance: number;
public solve (dy: number, world: World): number;
}
class Solver {
public iterations: number;
public tolerance: number;
public equations: Equation[];
public solve (dy: number, world: World): number;
public addEquation (eq: Equation): void;
public removeEquation (eq: Equation): void;
public removeAllEquations (): void;
}
class SplitSolver extends Solver {
public subsolver: Solver;
constructor (subsolver: Solver);
public solve (dy: number, world: World): number;
}
class EventTarget {
public addEventListener (type: string, listener: Function): EventTarget;
public hasEventListener (type: string, listener: Function): boolean;
public removeEventListener (type: string, listener: Function): EventTarget;
public dispatchEvent (event: IEvent): IEvent;
}
class Pool {
public objects: any[];
public type: any[];
public release (): any;
public get (): any;
public constructObject (): any;
}
class TupleDictionary {
public data: {
keys: any[];
};
public get (i: number, j: number): number;
public set (i: number, j: number, value: number): void;
public reset (): void;
}
class Utils {
public static defaults (options?: any, defaults?: any): any;
}
class Vec3Pool extends Pool {
public type: any;
public constructObject (): Vec3;
}
class NarrowPhase {
public contactPointPool: Pool[];
public v3pool: Vec3Pool;
}
class World extends EventTarget {
public iterations: number;
public dt: number;
public allowSleep: boolean;
public contacts: ContactEquation[];
public frictionEquations: FrictionEquation[];
public quatNormalizeSkip: number;
public quatNormalizeFast: boolean;
public time: number;
public stepnumber: number;
public default_dt: number;
public nextId: number;
public gravity: Vec3;
public broadphase: NaiveBroadphase;
public bodies: Body[];
public solver: Solver;
public constraints: Constraint[];
public narrowphase: NarrowPhase;
public collisionMatrix: ArrayCollisionMatrix;
public collisionMatrixPrevious: ArrayCollisionMatrix;
public materials: Material[];
public contactmaterials: ContactMaterial[];
public contactMaterialTable: TupleDictionary;
public defaultMaterial: Material;
public defaultContactMaterial: ContactMaterial;
public doProfiling: boolean;
public profile: {
solve: number;
makeContactConstraints: number;
broadphaser: number;
integrate: number;
narrowphase: number;
};
public subsystems: any[];
public addBodyEvent: IBodyEvent;
public removeBodyEvent: IBodyEvent;
public getContactMaterial (m1: Material, m2: Material): ContactMaterial;
public numObjects (): number;
public collisionMatrixTick (): void;
public addBody (body: Body): void;
public addConstraint (c: Constraint): void;
public removeConstraint (c: Constraint): void;
public rayTest (from: Vec3, to: Vec3, result: RaycastResult): void;
public remove (body: Body): void;
public addMaterial (m: Material): void;
public addContactMaterial (cmat: ContactMaterial): void;
public step (dy: number, timeSinceLastCalled?: number, maxSubSteps?: number): void;
/** raycast */
public raycastAny (from: Vec3, to: Vec3, options: IRaycastOptions, result: RaycastResult): boolean;
public raycastClosest (from: Vec3, to: Vec3, options: IRaycastOptions, result: RaycastResult): boolean;
public raycastAll (from: Vec3, to: Vec3, options: IRaycastOptions, callback: (result: RaycastResult) => {}): boolean;
// public raycastCollider()
/** events */
public emitTriggeredEvents (): void;
public emitCollisionEvents (): void;
}
interface IRaycastOptions {
collisionFilterMask?: number,
collisionFilterGroup?: number;
skipBackFaces?: boolean;
checkCollisionResponse?: boolean;
}
interface IEvent {
target: any;
type: string;
}
interface ITriggeredEvent extends IEvent {
event: 'onTriggerEnter' | 'onTriggerStay' | 'onTriggerExit';
selfBody: Body;
otherBody: Body;
selfShape: Shape;
otherShape: Shape;
}
interface IBodyEvent extends IEvent {
type: '';
body: Body;
target: Body;
contact: ContactEquation;
}
interface ICollisionEvent extends IBodyEvent {
event: 'onCollisionEnter' | 'onCollisionStay' | 'onCollisionExit';
selfShape: Shape;
otherShape: Shape;
contacts: ContactEquation[];
}
}
declare module '@cocos/cannon' {
export = CANNON;
}