Enum RigidBody

pub enum RigidBody {
    Dynamic,
    Static,
    Kinematic,
}

A non-deformable body used for the simulation of most physics objects.

Rigid Body Types

A rigid body can be either dynamic, kinematic or static.

• Dynamic bodies are similar to real life objects and are affected by forces and contacts.
• Kinematic bodies can only be moved programmatically, which is useful for things like character controllers and moving platforms.
• Static bodies can not move, so they can be good for objects in the environment like the ground and walls.

Creation

Creating a rigid body is as simple as adding the RigidBody component, and an optional Collider:

use avian3d::prelude::*;
use bevy::prelude::*;

fn setup(mut commands: Commands) {
    // Spawn a dynamic rigid body and specify its position.
    commands.spawn((
        RigidBody::Dynamic,
        Collider::capsule(0.5, 1.5),
        Transform::from_xyz(0.0, 3.0, 0.0),
    ));
}

By default, dynamic rigid bodies will have mass properties computed based on the attached colliders and their ColliderDensity. See the Mass properties section for more information.

Movement

A rigid body can be moved in three ways: by modifying its position directly, by changing its velocity, or by applying forces or impulses.

To change the position of a rigid body, you can simply modify its Transform:

use avian3d::prelude::*;
use bevy::prelude::*;

fn move_bodies(mut query: Query<&mut Transform, With<RigidBody>>) {
    for mut transform in query.iter_mut() {
        transform.translation.x += 0.1;
    }
}

However, moving a dynamic body by changing its position directly is similar to teleporting the body, which can result in unexpected behavior since the body can move inside walls.

You can instead change the velocity of a dynamic or kinematic body with the LinearVelocity and AngularVelocity components:

use avian3d::prelude::*;
use bevy::prelude::*;

fn accelerate_bodies(mut query: Query<(&mut LinearVelocity, &mut AngularVelocity)>) {
    for (mut linear_velocity, mut angular_velocity) in query.iter_mut() {
        linear_velocity.x += 0.05;
        angular_velocity.z += 0.05;
    }
}

For applying forces and impulses to dynamic bodies, see the ExternalForce, ExternalTorque, ExternalImpulse and ExternalAngularImpulse components.

Avian does not have a built-in character controller, so if you need one, you will need to implement it yourself or use a third party option. You can take a look at the basic_dynamic_character and basic_kinematic_character examples for a simple implementation.

Mass Properties

Every dynamic rigid body has mass, angular inertia, and a center of mass. These mass properties determine how the rigid body responds to forces and torques.

• Mass: Represents resistance to linear acceleration. A higher mass requires more force for the same acceleration.
• Angular Inertia: Represents resistance to angular acceleration. A higher angular inertia requires more torque for the same angular acceleration.
• Center of Mass: The average position of mass in the body. Applying forces at this point produces no torque.

Static and kinematic rigid bodies have infinite mass and angular inertia, and do not respond to forces or torques. Zero mass for a dynamic body is also treated as a special case, and corresponds to infinite mass.

If no mass properties are set, they are computed automatically from attached colliders based on their shape and density.

// Note: `ColliderDensity` is optional, and defaults to `1.0` if not present.
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    ColliderDensity(2.0),
));

If mass properties are set with the Mass, AngularInertia, and CenterOfMass components, they override the values computed from colliders.

// Override mass and the center of mass, but use the collider's angular inertia.
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    Mass(5.0),
    CenterOfMass::new(0.0, -0.5, 0.0),
));

If the rigid body has child colliders, their mass properties will be combined for the total ComputedMass, ComputedAngularInertia, and ComputedCenterOfMass.

// Total mass: 10.0 + 5.0 = 15.0
// Total center of mass: (10.0 * [0.0, -0.5, 0.0] + 5.0 * [0.0, 4.0, 0.0]) / (10.0 + 5.0) = [0.0, 1.0, 0.0]
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    Mass(10.0),
    CenterOfMass::new(0.0, -0.5, 0.0),
    Transform::default(),
))
.with_child((
    Collider::sphere(1.0),
    Mass(5.0),
    Transform::from_xyz(0.0, 4.0, 0.0),
));

To prevent child entities from contributing to the total mass properties, use the NoAutoMass, NoAutoAngularInertia, and NoAutoCenterOfMass marker components.

// Total mass: 10.0
// Total center of mass: [0.0, -0.5, 0.0]
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    Mass(10.0),
    CenterOfMass::new(0.0, -0.5, 0.0),
    NoAutoMass,
    NoAutoCenterOfMass,
    Transform::default(),
))
.with_child((
    Collider::sphere(1.0),
    Mass(5.0),
    Transform::from_xyz(0.0, 4.0, 0.0),
));

See the mass_properties module for more information.

See More

• Colliders
• Gravity and gravity scale
• Linear and angular velocity damping
• Friction and restitution (bounciness)
• Lock translational and rotational axes
• Dominance
• Continuous Collision Detection
  • Speculative collision
  • Swept CCD
• Transform interpolation and extrapolation
• Temporarily disabling a rigid body
• Automatic deactivation with sleeping

Variants

Dynamic

Dynamic bodies are bodies that are affected by forces, velocity and collisions.

Static

Static bodies are not affected by any forces, collisions or velocity, and they act as if they have an infinite mass and moment of inertia. The only way to move a static body is to manually change its position.

Collisions with static bodies will affect dynamic bodies, but not other static bodies or kinematic bodies.

Static bodies are typically used for things like the ground, walls and any other objects that you don’t want to move.

Kinematic

Kinematic bodies are bodies that are not affected by any external forces or collisions. They will realistically affect colliding dynamic bodies, but not other kinematic bodies.

Unlike static bodies, kinematic bodies can have velocity. The engine doesn’t modify the values of a kinematic body’s components, so you have full control of them.

Implementations

impl RigidBody

pub fn is_dynamic(&self) -> bool

Checks if the rigid body is dynamic.

pub fn is_static(&self) -> bool

Checks if the rigid body is static.

pub fn is_kinematic(&self) -> bool

Checks if the rigid body is kinematic.

Trait Implementations

impl Clone for RigidBody

fn clone(&self) -> RigidBody

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for RigidBody

where Self: Send + Sync + 'static,

Required Components: LinearVelocity, AngularVelocity, ExternalForce, ExternalTorque, ExternalImpulse, ExternalAngularImpulse, ComputedMass, ComputedAngularInertia, ComputedCenterOfMass, AccumulatedTranslation, PreSolveAccumulatedTranslation, [PreSolveLinearVelocity], [PreSolveAngularVelocity], PreSolveRotation, PreviousRotation, GlobalAngularInertia.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.

fn register_component_hooks(hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl Debug for RigidBody

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RigidBody

fn default() -> RigidBody

Returns the “default value” for a type.

impl Enum for RigidBody

where RigidBody: Any + Send + Sync,

fn field(&self, __name_param: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field (in the current variant) with the given name.

fn field_at(&self, __index_param: usize) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field (in the current variant) at the given index.

fn field_mut(&mut self, __name_param: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field (in the current variant) with the given name.

fn field_at_mut( &mut self, __index_param: usize, ) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

fn name_at(&self, __index_param: usize) -> Option<&str>

Returns the name of the field (in the current variant) with the given index.

fn iter_fields(&self) -> VariantFieldIter<'_>

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn clone_dynamic(&self) -> DynamicEnum

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

fn get_represented_enum_info(&self) -> Option<&'static EnumInfo>

Will return None if TypeInfo is not available.

impl FromReflect for RigidBody

where RigidBody: Any + Send + Sync,

fn from_reflect(__param0: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for RigidBody

where RigidBody: Any + Send + Sync,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl PartialEq for RigidBody

fn eq(&self, other: &RigidBody) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialReflect for RigidBody

where RigidBody: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

fn try_apply( &mut self, __value_param: &dyn PartialReflect, ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn debug(&self, f: &mut Formatter<'_>) -> Result

Debug formatter for the value.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for RigidBody

where RigidBody: Any + Send + Sync,

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl TypePath for RigidBody

where RigidBody: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for RigidBody

where RigidBody: Any + Send + Sync,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for RigidBody

impl Eq for RigidBody

impl StructuralPartialEq for RigidBody