Body | p2-es

A rigid body. Has got a center of mass, position, velocity and a number of shapes that are used for collisions.

example

// Create a typical dynamic body
var body = new Body({
    mass: 1, // non-zero mass will set type to Body.DYNAMIC
    position: [0, 5],
    angle: 0,
    velocity: [0, 0],
    angularVelocity: 0
});

// Add a circular shape to the body
var circleShape = new Circle({ radius: 0.5 });
body.addShape(circleShape);

// Add the body to the world
world.addBody(body);

example

// Create a static plane body
var planeBody = new Body({
    mass: 0, // zero mass will set type to Body.STATIC
    position: [0, 0]
});
var planeShape = new Plane();
planeBody.addShape(planeShape);
world.addBody(planeBody);

example

// Create a moving kinematic box body
var platformBody = new Body({
    type: Body.KINEMATIC,
    position: [0, 3],
    velocity: [1, 0]
});
var boxShape = new Box({ width: 2, height: 0.5 });
platformBody.addShape(boxShape);
world.addBody(platformBody);

Hierarchy

EventEmitter<BodyEventMap>
- Body

Index

Constructors

constructor

Constructors

constructor

new Body(options?: BodyOptions): Body

Overrides EventEmitter.constructor
- Defined in objects/Body.ts:526
Parameters
- options: BodyOptions = {}
Returns Body

Properties

aabb

aabb: AABB

Bounding box of this body. Update with Body.updateAABB.

aabbNeedsUpdate

aabbNeedsUpdate: boolean

Indicates if the AABB needs update. Update it with {@link "Body.updateAABB"}.

example

// Force update the AABB
body.aabbNeedsUpdate = true;
body.updateAABB();
console.log(body.aabbNeedsUpdate); // false

allowSleep

allowSleep: boolean

If true, the body will automatically fall to sleep. Note that you need to enable sleeping in the World before anything will happen.

default: true

angle

angle: number

The angle of the body, in radians.

example

// The angle property is not normalized to the interval 0 to 2*pi, it can be any value.
// If you need a value between 0 and 2*pi, use the following function to normalize it.
function normalizeAngle(angle){
    angle = angle % (2*Math.PI);
    if(angle < 0){
        angle += (2*Math.PI);
    }
    return angle;
}

angularDamping

angularDamping: number

The angular force acting on the body. Should be a value between 0 and 1.

default: 0.1

angularForce

angularForce: number

The angular force acting on the body. See Body.force.

angularVelocity

angularVelocity: number

The angular velocity of the body, in radians per second.

boundingRadius

boundingRadius: number

Bounding circle radius. Update with Body.updateBoundingRadius.

ccdIterations

ccdIterations: number

The number of iterations that should be used when searching for the time of impact during CCD. A larger number will assure that there's a small penetration on CCD collision, but a small number will give more performance.

default: 10

ccdSpeedThreshold

ccdSpeedThreshold: number

If the body speed exceeds this threshold, CCD (continuous collision detection) will be enabled. Set it to a negative number to disable CCD completely for this body.

default: -1

collisionResponse

collisionResponse: boolean

Whether to produce contact forces when in contact with other bodies. Note that contacts will be generated, but they will be disabled. That means that this body will move through other bodies, but it will still trigger contact events, etc.

damping

damping: number

The linear damping acting on the body in the velocity direction. Should be a value between 0 and 1.

default: 0.1

fixedRotation

fixedRotation: boolean

Set to true if you want to fix the rotation of the body.

example

// Fix rotation during runtime
body.fixedRotation = true;
body.updateMassProperties();

fixedX

fixedX: boolean

Set to true if you want to fix the body movement along the X axis. The body will still be able to move along Y.

example

// Fix X movement on body creation
var body = new Body({ mass: 1, fixedX: true });

example

// Fix X movement during runtime
body.fixedX = true;
body.updateMassProperties();

fixedY

fixedY: boolean

Set to true if you want to fix the body movement along the Y axis. The body will still be able to move along X. See .fixedX

force

force: Vec2

The force acting on the body. Since the body force (and Body.angularForce) will be zeroed after each step, so you need to set the force before each step.

example

// This produces a forcefield of 1 Newton in the positive x direction.
for(var i=0; i<numSteps; i++){
    body.force[0] = 1;
    world.step(1/60);
}

example

// This will apply a rotational force on the body
for(var i=0; i<numSteps; i++){
    body.angularForce = -3;
    world.step(1/60);
}

gravityScale

gravityScale: number

Gravity scaling factor. If you want the body to ignore gravity, set this to zero. If you want to reverse gravity, set it to -1.

default: 1

id

id: number

The body identifier

idleTime

idleTime: number

How long the body has been sleeping.

index

index: number

Index of the body in the World .bodies array. Is set to -1 if the body isn't added to a World.

inertia

inertia: number

The inertia of the body around the Z axis.

interpolatedAngle

interpolatedAngle: number

The interpolated angle of the body. Use this for rendering.

interpolatedPosition

interpolatedPosition: Vec2

The interpolated position of the body. Use this for rendering.

invInertia

invInertia: number

The inverse inertia of the body.

invInertiaSolve

invInertiaSolve: number

invMass

invMass: number

The inverse mass of the body.

invMassSolve

invMassSolve: number

mass

mass: number

The mass of the body. If you change this number, you should call Body.updateMassProperties.

example

body.mass = 1;
body.updateMassProperties();

position

position: Vec2

The position of the body in the world. Don't use this for rendering, instead use .interpolatedPosition

previousAngle

previousAngle: number

The previous angle of the body.

previousPosition

previousPosition: Vec2

The previous position of the body.

shapes

shapes: Shape[]

The shapes of the body.

sleepSpeedLimit

sleepSpeedLimit: number

If the speed (the norm of the velocity) is smaller than this value, the body is considered sleepy.

default: 0.2

sleepState

sleepState: 0 | 2 | 1

One of Body.AWAKE, Body.SLEEPY and Body.SLEEPING.

The body is initially Body.AWAKE. If its velocity norm is below .sleepSpeedLimit, the sleepState will become Body.SLEEPY. If the body continues to be Body.SLEEPY for .sleepTimeLimit seconds, it will fall asleep (Body.SLEEPY).

default: Body.AWAKE

sleepTimeLimit

sleepTimeLimit: number

If the body has been sleepy for this sleepTimeLimit seconds, it is considered sleeping.

default: 1

timeLastSleepy

timeLastSleepy: number

The last time when the body went to SLEEPY state.

type

type: 2 | 1 | 4

The type of motion this body has. Should be one of: Body.STATIC, Body.DYNAMIC and Body.KINEMATIC.

Static bodies do not move, and they do not respond to forces or collision.
Dynamic bodies body can move and respond to collisions and forces.
Kinematic bodies only moves according to its .velocity, and does not respond to collisions or force.

example

// Bodies are static by default. Static bodies will never move.
var body = new Body();
console.log(body.type == Body.STATIC); // true

example

// By setting the mass of a body to a nonzero number, the body
// will become dynamic and will move and interact with other bodies.
var dynamicBody = new Body({
    mass : 1
});
console.log(dynamicBody.type == Body.DYNAMIC); // true

example

// Kinematic bodies will only move if you change their velocity.
var kinematicBody = new Body({
    type: Body.KINEMATIC // Type can be set via the options object.
});

velocity

velocity: Vec2

The current velocity of the body.

vlambda

vlambda: Vec2

Constraint velocity that was added to the body during the last step.

wantsToSleep

wantsToSleep: boolean

Whether the body wants to sleep

wlambda

wlambda: number

Angular constraint velocity that was added to the body during last step.

world

world: null | World = null

The world that this body is added to (read only). This property is set to NULL if the body is not added to any world.

Static AWAKE

AWAKE: 0 = 0

Awake sleep state.

Static DYNAMIC

DYNAMIC: 1 = 1

Dynamic body.

Static KINEMATIC

KINEMATIC: 4 = 4

Kinematic body.

Static SLEEPING

SLEEPING: 2 = 2

Sleeping sleep state.

Static SLEEPY

SLEEPY: 1 = 1

Sleepy sleep state.

Static STATIC

STATIC: 2 = 2

Static body.

Static _idCounter

_idCounter: number = 0

Id counter for Body instances

Methods

addConstraintVelocity

addConstraintVelocity(): void

- Defined in objects/Body.ts:1367
Returns void

addShape

addShape(shape: Shape, offset?: Vec2, angle?: number): void

Add a shape to the body. You can pass a local transform when adding a shape, so that the shape gets an offset and angle relative to the body center of mass. Will automatically update the mass properties and bounding radius.

example

var body = new Body(),
    shape = new Circle({ radius: 1 });

// Add the shape to the body, positioned in the center
body.addShape(shape);

// Add another shape to the body, positioned 1 unit length from the body center of mass along the local x-axis.
body.addShape(shape,[1,0]);

// Add another shape to the body, positioned 1 unit length from the body center of mass along the local y-axis, and rotated 90 degrees CCW.
body.addShape(shape,[0,1],Math.PI/2);

Parameters

shape: Shape
Optional offset: Vec2

Local body offset of the shape.
Optional angle: number

Local body angle.

Returns void

adjustCenterOfMass

adjustCenterOfMass(): void

Moves the shape offsets so their center of mass becomes the body center of mass.

example

var body = new Body({ position: [0, 0] });
var shape = new Circle({ radius: 1 });
body.addShape(shape, [1, 0], 0);
body.adjustCenterOfMass();
console.log(body.position); // [1, 0]
console.log(shape.position); // [0, 0]

Returns void

applyDamping

applyDamping(dt: number): void

- Defined in objects/Body.ts:1105
Apply damping, see this for details.

Parameters
- dt: number
  
  Current time step
Returns void

applyForce

applyForce(force: Vec2, relativePoint?: Vec2): void

- Defined in objects/Body.ts:816
Apply force to a point relative to the center of mass of the body. This could for example be a point on the Body surface. Applying force this way will add to Body.force and Body.angularForce.
example
```
var body = new Body({ mass: 1 });
var relativePoint = [1, 0]; // Will apply the force at [body.position[0] + 1, body.position[1]]
var force = [0, 1]; // up
body.applyForce(force, relativePoint);
console.log(body.force); // [0, 1]
console.log(body.angularForce); // 1
```
Parameters
- force: Vec2
  
  The force vector to add, oriented in world space.
- Optional relativePoint: Vec2
  
  A point relative to the body in world space. If not given, it is set to zero and all of the force will be exerted on the center of mass.
Returns void

applyForceLocal

applyForceLocal(localForce: Vec2, localPoint?: Vec2): void

- Defined in objects/Body.ts:841
Apply force to a point relative to the center of mass of the body. This could for example be a point on the Body surface. Applying force this way will add to Body.force and Body.angularForce.
example
```
var body = new Body({ mass: 1 });
var localPoint = [1, 0]; // x=1 locally in the body
var localForce = [0, 1]; // up, locally in the body
body.applyForceLocal(localForce, localPoint);
console.log(body.force); // [0, 1]
console.log(body.angularForce); // 1
```
Parameters
- localForce: Vec2
  
  The force vector to add, oriented in local body space.
- Optional localPoint: Vec2
  
  A point relative to the body in local body space. If not given, it is set to zero and all of the force will be exerted on the center of mass.
Returns void

applyImpulse

applyImpulse(impulseVector: Vec2, relativePoint?: Vec2): void

- Defined in objects/Body.ts:862
Apply impulse to a point relative to the body. This could for example be a point on the Body surface. An impulse is a force added to a body during a short period of time (impulse = force * time). Impulses will be added to Body.velocity and Body.angularVelocity.
example
```
var body = new Body({ mass: 1 });
var relativePoint = [0, 0]; // center of the body
var impulseVector = [0, 1]; // world up
body.applyImpulse(impulseVector, relativePoint);
```
Parameters
- impulseVector: Vec2
  
  The impulse vector to add, oriented in world space.
- Optional relativePoint: Vec2
  
  A point relative to the body in world space. If not given, it is set to zero and all of the impulse will be exerted on the center of mass.
Returns void

applyImpulseLocal

applyImpulseLocal(localImpulse: Vec2, localPoint?: Vec2): void

- Defined in objects/Body.ts:897
Apply impulse to a point relative to the body. This could for example be a point on the Body surface. An impulse is a force added to a body during a short period of time (impulse = force * time). Impulses will be added to Body.velocity and Body.angularVelocity.
example
```
var body = new Body({ mass: 1 });
var localPoint = [1, 0]; // x=1, locally in the body
var localImpulse = [0, 1]; // up, locally in the body
body.applyImpulseLocal(localImpulse, localPoint);
console.log(body.velocity); // [1, 0]
console.log(body.angularVelocity); // 1
```
Parameters
- localImpulse: Vec2
  
  The impulse vector to add, oriented in local body space.
- Optional localPoint: Vec2
  
  A point relative to the body in local body space. If not given, it is set to zero and all of the impulse will be exerted on the center of mass.
Returns void

emit

emit<E>(event: BodyEventMap[E]): EventEmitter<BodyEventMap>

Inherited from EventEmitter.emit
- Defined in events/EventEmitter.ts:97
Emit an event.
example
```
emitter.emit({
    type: 'myEvent',
    customData: 123
});
```
Type Parameters
- E extends keyof BodyEventMap
Parameters
- event: BodyEventMap[E]
Returns EventEmitter<BodyEventMap>
The self object, for chainability.

fromPolygon

fromPolygon(path: Vec2[], options?: { optimalDecomp?: boolean; removeCollinearPoints?: number | boolean; skipSimpleCheck?: boolean }): boolean

- Defined in objects/Body.ts:962
Reads a polygon shape path, and assembles convex shapes from that and puts them at proper offset points.
example
```
var body = new Body();
var path = [
    [-1, 1],
    [-1, 0],
    [1, 0],
    [1, 1],
    [0.5, 0.5]
];
body.fromPolygon(path);
console.log(body.shapes); // [Convex, Convex, ...]
```
Parameters
- path: Vec2[]
  
  An array of 2d vectors, e.g. [[0,0],[0,1],...] that resembles a concave or convex polygon. The shape must be simple and without holes.
- options: { optimalDecomp?: boolean; removeCollinearPoints?: number | boolean; skipSimpleCheck?: boolean } = {}
  - Optional optimalDecomp?: boolean
  - Optional removeCollinearPoints?: number | boolean
  - Optional skipSimpleCheck?: boolean
Returns boolean
True on success, else false.

getAABB

getAABB(): AABB

- Defined in objects/Body.ts:638
Get the AABB from the body. The AABB is updated if necessary.

Returns AABB
The AABB instance from the body.

getArea

getArea(): number

- Defined in objects/Body.ts:626
Get the total area of all shapes in the body

Returns number
total area of all shapes in the body

getVelocityAtPoint

getVelocityAtPoint(result: Vec2, relativePoint: Vec2): Vec2

- Defined in objects/Body.ts:1245
Get velocity of a point in the body.
example
```
var body = new Body({
    mass: 1,
    velocity: [1, 0],
    angularVelocity: 1
});
var result = [];
var point = [1, 0];
body.getVelocityAtPoint(result, point);
console.log(result); // [1, 1]
```
Parameters
- result: Vec2
  
  A vector to store the result in
- relativePoint: Vec2
  
  A world oriented vector, indicating the position of the point to get the velocity from
Returns Vec2
The result vector

has

has<E>(type: E, listener?: Function): boolean

Inherited from EventEmitter.has
- Defined in events/EventEmitter.ts:68
Check if an event listener is added

Type Parameters
- E extends keyof BodyEventMap
Parameters
- type: E
- Optional listener: Function
Returns boolean

integrate

integrate(dt: number): void

- Defined in objects/Body.ts:1197
Move the body forward in time given its current velocity.

Parameters
- dt: number
Returns void

integrateToTimeOfImpact

integrateToTimeOfImpact(dt: number): boolean

- Defined in objects/Body.ts:1251
Parameters
- dt: number
Returns boolean

off

off<E>(type: E, listener: Function): EventEmitter<BodyEventMap>

Inherited from EventEmitter.off
- Defined in events/EventEmitter.ts:51
Remove an event listener
example
```
emitter.on('myEvent', handler); // Add handler
emitter.off('myEvent', handler); // Remove handler
```
Type Parameters
- E extends keyof BodyEventMap
Parameters
- type: E
- listener: Function
Returns EventEmitter<BodyEventMap>
The self object, for chainability.

on

on<E>(type: E, listener: ((e: BodyEventMap[E]) => void), context?: any): EventEmitter<BodyEventMap>

Inherited from EventEmitter.on
- Defined in events/EventEmitter.ts:29
Add an event listener
example
```
emitter.on('myEvent', function(evt){
    console.log('myEvt was triggered!');
});
```
Type Parameters
- E extends keyof BodyEventMap
Parameters
- type: E
- listener: ((e: BodyEventMap[E]) => void)
  - - (e: BodyEventMap[E]): void
    - Parameters
      - e: BodyEventMap[E]
      Returns void
- Optional context: any
Returns EventEmitter<BodyEventMap>
The self object, for chainability.

overlaps

overlaps(body: Body): boolean

- Defined in objects/Body.ts:1186
Check if the body is overlapping another body. Note that this method only works if the body was added to a World and if at least one step was taken.

Parameters
- body: Body
Returns boolean
if the body overlaps the given body

removeShape

removeShape(shape: Shape): boolean

- Defined in objects/Body.ts:747
Remove a shape.

Parameters
- shape: Shape
Returns boolean
True if the shape was found and removed, else false.

resetConstraintVelocity

resetConstraintVelocity(): void

- Defined in objects/Body.ts:1361
Returns void

setDensity

setDensity(density: number): void

- Defined in objects/Body.ts:616
Set the total density of the body

Parameters
- density: number
Returns void

setZeroForce

setZeroForce(): void

- Defined in objects/Body.ts:1096
Sets the force on the body to zero.

Returns void

sleep

sleep(): void

- Defined in objects/Body.ts:1132
Force body sleep

Returns void

sleepTick

sleepTick(time: number, dontSleep: boolean, dt: number): void

- Defined in objects/Body.ts:1148
Called every timestep to update internal sleep timer and change sleep state if needed.

Parameters
- time: number
  
  The world time in seconds
- dontSleep: boolean
- dt: number
Returns void

toLocalFrame

toLocalFrame(out: Vec2, worldPoint: Vec2): void

- Defined in objects/Body.ts:911
Transform a world point to local body frame.

Parameters
- out: Vec2
  
  The point to store the result in
- worldPoint: Vec2
  
  The input world point
Returns void

toWorldFrame

toWorldFrame(out: Vec2, localPoint: Vec2): void

- Defined in objects/Body.ts:920
Transform a local point to world frame.

Parameters
- out: Vec2
  
  The point to store the result in
- localPoint: Vec2
  
  The input local point
Returns void

updateAABB

updateAABB(): void

- Defined in objects/Body.ts:648
Updates the AABB of the Body, and set .aabbNeedsUpdate = false.

Returns void

updateBoundingRadius

updateBoundingRadius(): void

- Defined in objects/Body.ts:677
Update the bounding radius of the body (this.boundingRadius). Should be done if any of the shape dimensions or positions are changed.

Returns void

updateMassProperties

updateMassProperties(): void

- Defined in objects/Body.ts:772
Updates .inertia, .invMass, .invInertia for this Body. Should be called when changing the structure or mass of the Body.
example
```
body.mass += 1;
body.updateMassProperties();
```
Returns void

updateSolveMassProperties

updateSolveMassProperties(): void

- Defined in objects/Body.ts:602
Returns void

vectorToLocalFrame

vectorToLocalFrame(out: Vec2, worldVector: Vec2): void

- Defined in objects/Body.ts:929
Transform a world vector to local body frame.

Parameters
- out: Vec2
  
  The vector to store the result in
- worldVector: Vec2
  
  The input world vector
Returns void

vectorToWorldFrame

vectorToWorldFrame(out: Vec2, localVector: Vec2): void

- Defined in objects/Body.ts:938
Transform a local vector to world frame.

Parameters
- out: Vec2
  
  The vector to store the result in
- localVector: Vec2
  
  The input local vector
Returns void

wakeUp

wakeUp(): void

- Defined in objects/Body.ts:1118
Wake the body up. Normally you should not need this, as the body is automatically awoken at events such as collisions. Sets the sleepState to Body.AWAKE and emits the wakeUp event if the body wasn't awake before.

Returns void

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

options: BodyOptions = {}

Returns Body

Properties

aabb

aabbNeedsUpdate

allowSleep

angle

angularDamping

angularForce

angularVelocity

boundingRadius

ccdIterations

ccdSpeedThreshold

collisionResponse

damping

fixedRotation

fixedX

fixedY

force

gravityScale

id

idleTime

index

inertia

interpolatedAngle

interpolatedPosition

invInertia

invInertiaSolve

invMass

invMassSolve

mass

position

previousAngle

previousPosition

shapes

sleepSpeedLimit

sleepState

sleepTimeLimit

timeLastSleepy

type

velocity

vlambda

wantsToSleep

wlambda

world

Static AWAKE

Static DYNAMIC

Static KINEMATIC

Static SLEEPING

Static SLEEPY

Static STATIC

Static _idCounter

Methods

addConstraintVelocity

Returns void

addShape

Parameters

shape: Shape

Optional offset: Vec2

Optional angle: number

Returns void

adjustCenterOfMass

Returns void

applyDamping

Parameters

dt: number

Returns void

applyForce

Parameters

force: Vec2

Optional relativePoint: Vec2

Returns void