A Number specifying the angle of the body, in radians.

Read only. Use Body.setAngularSpeed to set.

See Body.getAngularSpeed for details.

Read only. Use Body.setAngularVelocity to set.

See Body.getAngularVelocity for details.

Read only. Calculated automatically when vertices are set.

A Number that measures the area of the body's convex hull.

Read only. Calculated automatically when vertices are set.

An array of unique axis vectors (edge normals) used for collision detection. These are automatically calculated when vertices are set. They are constantly updated by Body.update during the simulation.

A Bounds object that defines the AABB region for the body. It is automatically calculated when vertices are set and constantly updated by Body.update during simulation.

Temporarily may hold parameters to be passed to Vertices.chamfer where supported by external functions.

See Vertices.chamfer for possible parameters this object may hold.

Currently only functions inside Matter.Bodies provide a utility using this property as a vertices pre-processing option.

Alternatively consider using Vertices.chamfer directly on vertices before passing them to a body creation function.

An Object that specifies the collision filtering properties of this body.

Collisions between two bodies will obey the following rules:

• If the two bodies have the same non-zero value of collisionFilter.group, they will always collide if the value is positive, and they will never collide if the value is negative.
• If the two bodies have different values of collisionFilter.group or if one (or both) of the bodies has a value of 0, then the category/mask rules apply as follows:

Each body belongs to a collision category, given by collisionFilter.category. This value is used as a bit field and the category should have only one bit set, meaning that the value of this property is a power of two in the range [1, 2^31]. Thus, there are 32 different collision categories available.

Each body also defines a collision bitmask, given by collisionFilter.mask which specifies the categories it collides with (the value is the bitwise AND value of all these categories).

Using the category/mask rules, two bodies A and B collide if each includes the other's category in its mask, i.e. (categoryA & maskB) !== 0 and (categoryB & maskA) !== 0 are both true.

A bit field that specifies the collision category this body belongs to. The category value should have only one bit set, for example 0x0001. This means there are up to 32 unique collision categories available. See body.collisionFilter for more information.

An Integer Number, that specifies the collision group this body belongs to. See body.collisionFilter for more information.

A bit mask that specifies the collision categories this body may collide with. See body.collisionFilter for more information.

Read only. Updated during engine update.

A Number that records the last delta time value used to update this body. Used to calculate speed and velocity.

Read only. Use Body.setDensity to set.

A Number that defines the density of the body (mass per unit area).

Mass will also be updated when set.

A Vector that accumulates the total force applied to the body for a single update. Force is zeroed after every Engine.update, so constant forces should be applied for every update they are needed. See also Body.applyForce.

A Number that defines the friction of the body. The value is always positive and is in the range (0, 1). A value of 0 means that the body may slide indefinitely. A value of 1 means the body may come to a stop almost instantly after a force is applied.

The effects of the value may be non-linear. High values may be unstable depending on the body. The engine uses a Coulomb friction model including static and kinetic friction. Note that collision response is based on pairs of bodies, and that friction values are combined with the following formula:

Math.min(bodyA.friction, bodyB.friction)

A Number that defines the air friction of the body (air resistance). A value of 0 means the body will never slow as it moves through space. The higher the value, the faster a body slows when moving through space. The effects of the value are non-linear.

A Number that defines the static friction of the body (in the Coulomb friction model). A value of 0 means the body will never 'stick' when it is nearly stationary and only dynamic friction is used. The higher the value (e.g. 10), the more force it will take to initially get the body moving when nearly stationary. This value is multiplied with the friction property to make it easier to change friction and maintain an appropriate amount of static friction.

An integer Number uniquely identifying number generated in Body.create by Common.nextId.

Read only. Automatically calculated when vertices, mass or density are set or set through Body.setInertia.

A Number that defines the moment of inertia of the body. This is the second moment of area in two dimensions.

Can be manually set to Infinity to prevent rotation of the body. See Body.setInertia.

Read only. Automatically calculated when vertices, mass or density are set or calculated by Body.setInertia.

A Number that defines the inverse moment of inertia of the body (1 / inertia).

Read only. Use Body.setMass to set.

A Number that defines the inverse mass of the body (1 / mass).

A flag that indicates whether a body is a sensor. Sensor triggers collision events, but doesn't react with colliding body physically.

Read only. Use Sleeping.set to set.

A flag that indicates whether the body is considered sleeping. A sleeping body acts similar to a static body, except it is only temporary and can be awoken.

Read only. Use Body.setStatic to set.

A flag that indicates whether a body is considered static. A static body can never change position or angle and is completely fixed.

An arbitrary String name to help the user identify and manage bodies.

Read only. Use Body.setMass to set.

A Number that defines the mass of the body.

Density will also be updated when set.

Read only. Calculated during engine update only when sleeping is enabled.

A Number that loosely measures the amount of movement a body currently has.

Derived from body.speed^2 + body.angularSpeed^2. See Sleeping.update.

Read only. Updated by Body.setParts.

A reference to the body that this is a part of. See body.parts. This is a self reference if the body is not a part of another body.

Read only. Use Body.setParts to set.

See Bodies.fromVertices for a related utility.

An array of bodies (the 'parts') that make up this body (the 'parent'). The first body in this array must always be a self-reference to this body.

The parts are fixed together and therefore perform as a single unified rigid body.

Parts in relation to each other are allowed to overlap, as well as form gaps or holes, so can be used to create complex concave bodies unlike when using a single part.

Use properties and functions on the parent body rather than on parts.

Outside of their geometry, most properties on parts are not considered or updated.
As such 'per-part' material properties among others are not currently considered.

Parts should be created specifically for their parent body.
Parts should not be shared or reused between bodies, only one parent is supported.
Parts should not have their own parts, they are not handled recursively.
Parts should not be added to the world directly or any other composite.
Parts own vertices must be convex and in clockwise order.

A body with more than one part is sometimes referred to as a 'compound' body.

Use Body.setParts when setting parts to ensure correct updates of all properties.

An object reserved for storing plugin-specific properties.

Read only. Use Body.setPosition to set.

A Vector that specifies the current world-space position of the body.

An Object that defines the rendering properties to be consumed by the module Matter.Render.

A String that defines the fill style to use when rendering the body (if a sprite is not defined). It is the same as when using a canvas, so it accepts CSS style property values.

A Number that defines the line width to use when rendering the body outline (if a sprite is not defined). A value of 0 means no outline will be rendered.

Sets the opacity to use when rendering.

An Object that defines the sprite properties to use when rendering, if any.

An String that defines the path to the image to use as the sprite texture, if any.

A Number that defines the offset in the x-axis for the sprite (normalised by texture width).

A Number that defines the scaling in the x-axis for the sprite, if any.

A Number that defines the offset in the y-axis for the sprite (normalised by texture height).

A Number that defines the scaling in the y-axis for the sprite, if any.

A String that defines the stroke style to use when rendering the body outline (if a sprite is not defined). It is the same as when using a canvas, so it accepts CSS style property values.

A flag that indicates if the body should be rendered.

A Number that defines the restitution (elasticity) of the body. The value is always positive and is in the range (0, 1). A value of 0 means collisions may be perfectly inelastic and no bouncing may occur. A value of 0.8 means the body may bounce back with approximately 80% of its kinetic energy. Note that collision response is based on pairs of bodies, and that restitution values are combined with the following formula:

Math.max(bodyA.restitution, bodyB.restitution)

A Number that defines the length of time during which this body must have near-zero velocity before it is set as sleeping by the Matter.Sleeping module (if sleeping is enabled by the engine).

A Number that specifies a thin boundary around the body where it is allowed to slightly sink into other bodies.

This is required for proper collision response, including friction and restitution effects.

The default should generally suffice in most cases. You may need to decrease this value for very small bodies that are nearing the default value in scale.

Read only. Use Body.setSpeed to set.

See Body.getSpeed for details.

Equivalent to the magnitude of body.velocity (always positive).

A Number that specifies per-body time scaling.

A Number that accumulates the total torque (turning force) applied to the body for a single update. See also Body.applyForce. Torque is zeroed after every Engine.update, so constant torques should be applied for every update they are needed.

Torques result in angular acceleration on every update, which depends on body inertia and the engine update delta.

Read only. Set by Body.create.

A String denoting the type of object.

Read only. Use Body.setVelocity to set.

See Body.getVelocity for details.

Equivalent to the magnitude of body.angularVelocity (always positive).

Read only. Use Body.setVertices or Body.setParts to set. See also Bodies.fromVertices.

An array of Vector objects that specify the convex hull of the rigid body. These should be provided about the origin (0, 0). E.g.

[{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]

Vertices must always be convex, in clockwise order and must not contain any duplicate points.

Concave vertices should be decomposed into convex parts, see Bodies.fromVertices and Body.setParts.

When set the vertices are translated such that body.position is at the centre of mass. Many other body properties are automatically calculated from these vertices when set including density, area and inertia.

The module Matter.Vertices contains useful methods for working with vertices.