Class World

The physics world

Hierarchy (view full)

EventTarget_2
- World

Index

Constructors

constructor

Constructors

constructor

new World(options?): World
Parameters
- Optional options: {
      allowSleep?: boolean;
      broadphase?: Broadphase;
      frictionGravity?: Vec3;
      gravity?: Vec3;
      quatNormalizeFast?: boolean;
      quatNormalizeSkip?: number;
      solver?: Solver;
  }
  - Optional allowSleep?: boolean
    Makes bodies go to sleep when they've been inactive.
    Default
    false
  - Optional broadphase?: Broadphase
    The broadphase algorithm to use.
    Default
    NaiveBroadphase
  - Optional frictionGravity?: Vec3
    Gravity to use when approximating the friction max force (mumassgravity). If undefined, global gravity will be used.
  - Optional gravity?: Vec3
    The gravity of the world.
  - Optional quatNormalizeFast?: boolean
    Set to true to use fast quaternion normalization. It is often enough accurate to use. If bodies tend to explode, set to false.
    Default
    false
  - Optional quatNormalizeSkip?: number
    How often to normalize quaternions. Set to 0 for every step, 1 for every second etc.. A larger value increases performance. If bodies tend to explode, set to a smaller value (zero to be sure nothing can go wrong).
    Default
    0
  - Optional solver?: Solver
    The solver algorithm to use.
    Default
    GSSolver
Returns World
Overrides EventTarget_2.constructor

Properties

accumulator

accumulator: number

Time accumulator for interpolation.

See

https://gafferongames.com/game-physics/fix-your-timestep/

addBodyEvent

addBodyEvent: {
body: Body;
type: "addBody";
}

Dispatched after a body has been added to the world.

Type declaration

body: Body
type: "addBody"

allowSleep

allowSleep: boolean

Makes bodies go to sleep when they've been inactive.

Default

false

bodies

bodies: Body[]

All bodies in this world

bodyOverlapKeeper

bodyOverlapKeeper: OverlapKeeper

broadphase

broadphase: Broadphase

The broadphase algorithm to use.

Default

NaiveBroadphase

collisionMatrix

collisionMatrix: ArrayCollisionMatrix

collisionMatrix

collisionMatrixPrevious

collisionMatrixPrevious: ArrayCollisionMatrix

CollisionMatrix from the previous step.

constraints

constraints: Constraint[]

contactMaterialTable

contactMaterialTable: TupleDictionary

Used to look up a ContactMaterial given two instances of Material.

contactmaterials

contactmaterials: ContactMaterial[]

All added contactmaterials.

contacts

contacts: ContactEquation[]

All the current contacts (instances of ContactEquation) in the world.

defaultContactMaterial

defaultContactMaterial: ContactMaterial

This contact material is used if no suitable contactmaterial is found for a contact.

defaultMaterial

defaultMaterial: Material

The default material of the bodies.

default_dt

default_dt: number

Default and last timestep sizes.

doProfiling

doProfiling: boolean

dt

dt: number

Currently / last used timestep. Is set to -1 if not available. This value is updated before each internal step, which means that it is "fresh" inside event callbacks.

frictionEquations

frictionEquations: FrictionEquation[]

`Optional` frictionGravity

frictionGravity?: Vec3

Gravity to use when approximating the friction max force (mu * mass * gravity). If undefined, global gravity will be used. Use to enable friction in a World with a null gravity vector (no gravity).

gravity

gravity: Vec3

The gravity of the world.

hasActiveBodies

hasActiveBodies: boolean

True if any bodies are not sleeping, false if every body is sleeping.

idToBodyMap

idToBodyMap: {
[id: number]: Body;
}

Type declaration

[id: number]: Body

`Optional` lastCallTime

lastCallTime?: number

narrowphase

narrowphase: Narrowphase

nextId

nextId: number

profile

profile: {
    broadphase: number;
    integrate: number;
    makeContactConstraints: number;
    narrowphase: number;
    solve: number;
}

Type declaration

broadphase: number
integrate: number
makeContactConstraints: number
narrowphase: number
solve: number

quatNormalizeFast

quatNormalizeFast: boolean

Set to true to use fast quaternion normalization. It is often enough accurate to use. If bodies tend to explode, set to false.

Default

false

quatNormalizeSkip

quatNormalizeSkip: number

How often to normalize quaternions. Set to 0 for every step, 1 for every second etc.. A larger value increases performance. If bodies tend to explode, set to a smaller value (zero to be sure nothing can go wrong).

Default

removeBodyEvent

removeBodyEvent: {
body: Body;
type: "removeBody";
}

Dispatched after a body has been removed from the world.

Type declaration

body: Body
type: "removeBody"

shapeOverlapKeeper

shapeOverlapKeeper: OverlapKeeper

solver

solver: Solver

The solver algorithm to use.

Default

GSSolver

stepnumber

stepnumber: number

Number of timesteps taken since start.

subsystems

subsystems: any[]

time

time: number

The wall-clock time since simulation start.

Methods

addBody

addBody(body): void
Add a rigid body to the simulation.
Parameters
- body: Body
Returns void
Todo
If the simulation has not yet started, why recrete and copy arrays for each body? Accumulate in dynamic arrays in this case.

Todo
Adding an array of bodies should be possible. This would save some loops too

addConstraint

addConstraint(c): void
Add a constraint to the simulation.
Parameters
- c: Constraint
Returns void

addContactMaterial

addContactMaterial(cmat): void
Adds a contact material to the World
Parameters
- cmat: ContactMaterial
Returns void

addEventListener

addEventListener(type, listener): EventTarget_2
Add an event listener
Parameters
- type: string
- listener: Function
Returns EventTarget_2
The self object, for chainability.

Inherited from EventTarget_2.addEventListener

clearForces

clearForces(): void
Sets all body forces in the world to zero.

Returns void

collisionMatrixTick

collisionMatrixTick(): void
Store old collision state info

Returns void

dispatchEvent

dispatchEvent(event): EventTarget_2
Emit an event.
Parameters
- event: any
Returns EventTarget_2
The self object, for chainability.

Inherited from EventTarget_2.dispatchEvent

emitContactEvents

emitContactEvents(): void
Returns void

fixedStep

fixedStep(dt?, maxSubSteps?): void
Step the simulation forward keeping track of last called time to be able to step the world at a fixed rate, independently of framerate.
Parameters
- Optional dt: number
  The fixed time step size to use (default: 1 / 60).
- Optional maxSubSteps: number
  Maximum number of fixed steps to take per function call (default: 10).
Returns void
See
https://gafferongames.com/post/fix_your_timestep/

Example
```
// Run the simulation independently of framerate every 1 / 60 ms
    world.fixedStep()
```

getBodyById

getBodyById(id): Body
Parameters
- id: number
Returns Body

getContactMaterial

getContactMaterial(m1, m2): ContactMaterial
Get the contact material between materials m1 and m2
Parameters
- m1: Material
- m2: Material
Returns ContactMaterial
The contact material if it was found.

getShapeById

getShapeById(id): Shape
Parameters
- id: number
Returns Shape
Todo
Make a faster map

hasAnyEventListener

hasAnyEventListener(type): boolean
Check if any event listener of the given type is added
Parameters
- type: string
Returns boolean
Inherited from EventTarget_2.hasAnyEventListener

hasEventListener

hasEventListener(type, listener): boolean
Check if an event listener is added
Parameters
- type: string
- listener: Function
Returns boolean
Inherited from EventTarget_2.hasEventListener

internalStep

internalStep(dt): void
Parameters
- dt: number
Returns void

rayTest

rayTest(from, to, result): void
Raycast test
Parameters
- from: Vec3
- to: Vec3
- result: RaycastResult | RaycastCallback
Returns void
Deprecated
Use .raycastAll, .raycastClosest or .raycastAny instead.

raycastAll

raycastAll(from?, to?, options?, callback?): boolean
Ray cast against all bodies. The provided callback will be executed for each hit with a RaycastResult as single argument.
Parameters
- Optional from: Vec3
- Optional to: Vec3
- Optional options: RayOptions
- Optional callback: RaycastCallback
Returns boolean
True if any body was hit.

raycastAny

raycastAny(from?, to?, options?, result?): boolean
Ray cast, and stop at the first result. Note that the order is random - but the method is fast.
Parameters
- Optional from: Vec3
- Optional to: Vec3
- Optional options: RayOptions
- Optional result: RaycastResult
Returns boolean
True if any body was hit.

raycastClosest

raycastClosest(from?, to?, options?, result?): boolean
Ray cast, and return information of the closest hit.
Parameters
- Optional from: Vec3
- Optional to: Vec3
- Optional options: RayOptions
- Optional result: RaycastResult
Returns boolean
True if any body was hit.

removeBody

removeBody(body): void
Remove a rigid body from the simulation.
Parameters
- body: Body
Returns void

removeConstraint

removeConstraint(c): void
Removes a constraint
Parameters
- c: Constraint
Returns void

removeContactMaterial

removeContactMaterial(cmat): void
Removes a contact material from the World.
Parameters
- cmat: ContactMaterial
Returns void

removeEventListener

removeEventListener(type, listener): EventTarget_2
Remove an event listener
Parameters
- type: string
- listener: Function
Returns EventTarget_2
The self object, for chainability.

Inherited from EventTarget_2.removeEventListener

step

step(dt, timeSinceLastCalled?, maxSubSteps?): void
Step the physics world forward in time.

There are two modes. The simple mode is fixed timestepping without interpolation. In this case you only use the first argument. The second case uses interpolation. In that you also provide the time since the function was last used, as well as the maximum fixed timesteps to take.
Parameters
- dt: number
  The fixed time step size to use.
- Optional timeSinceLastCalled: number
  The time elapsed since the function was last called.
- Optional maxSubSteps: number
  Maximum number of fixed steps to take per function call (default: 10).
Returns void
See
https://web.archive.org/web/20180426154531/http://bulletphysics.org/mediawiki-1.5.8/index.php/Stepping_The_World#What_do_the_parameters_to_btDynamicsWorld::stepSimulation_mean.3F

Example
```
// fixed timestepping without interpolation
    world.step(1 / 60)
```

Class World

Hierarchy (view full)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Optional options: { allowSleep?: boolean; broadphase?: Broadphase; frictionGravity?: Vec3; gravity?: Vec3; quatNormalizeFast?: boolean; quatNormalizeSkip?: number; solver?: Solver; }

Optional allowSleep?: boolean

Default

Optional broadphase?: Broadphase

Default

Optional frictionGravity?: Vec3

Optional gravity?: Vec3

Optional quatNormalizeFast?: boolean

Default

Optional quatNormalizeSkip?: number

Default

Optional solver?: Solver

Default

Returns World

Properties

accumulator

See

addBodyEvent

Type declaration

body: Body

type: "addBody"

allowSleep

Default

bodies

bodyOverlapKeeper

broadphase

Default

collisionMatrix

collisionMatrixPrevious

constraints

contactMaterialTable

contactmaterials

contacts

defaultContactMaterial

defaultMaterial

default_dt

doProfiling

dt

frictionEquations

Optional frictionGravity

gravity

hasActiveBodies

idToBodyMap

Type declaration

[id: number]: Body

Optional lastCallTime

narrowphase

nextId

profile

Type declaration

broadphase: number

integrate: number

makeContactConstraints: number

narrowphase: number

solve: number

quatNormalizeFast

Default

quatNormalizeSkip

Default

removeBodyEvent

Type declaration

body: Body

type: "removeBody"

shapeOverlapKeeper

solver

Default

stepnumber

subsystems

time

Methods

addBody

`Optional` options: {
allowSleep?: boolean;
broadphase?: Broadphase;
frictionGravity?: Vec3;
gravity?: Vec3;
quatNormalizeFast?: boolean;
quatNormalizeSkip?: number;
solver?: Solver;
}

`Optional` allowSleep?: boolean

`Optional` broadphase?: Broadphase

`Optional` frictionGravity?: Vec3

`Optional` gravity?: Vec3

`Optional` quatNormalizeFast?: boolean

`Optional` quatNormalizeSkip?: number

`Optional` solver?: Solver

`Optional` frictionGravity

`Optional` lastCallTime

`Optional` dt: number

`Optional` maxSubSteps: number