Enum bevy_xpbd_3d::components::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:

use bevy::prelude::*;
use bevy_xpbd_3d::prelude::*;

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

Bevy XPBD will automatically add any missing components, like the following:

• Position
• Rotation
• LinearVelocity
• AngularVelocity
• ExternalForce
• ExternalTorque
• ExternalImpulse
• ExternalAngularImpulse
• Friction
• Restitution
• Mass
• Inertia
• CenterOfMass

You can change any of these during initialization and runtime in order to alter the behaviour of the body.

By default, rigid bodies will get a mass based on their collider and density. See mass properties.

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 bevy::prelude::*;
use bevy_xpbd_3d::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 bevy::prelude::*;
use bevy_xpbd_3d::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.

Bevy XPBD 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

The mass properties of a rigid body consist of its Mass, Inertia and local CenterOfMass. They control how forces and torques impact a rigid body and how it affects other bodies.

You should always give dynamic rigid bodies mass properties so that forces are applied to them correctly. The easiest way to do that is to simply add a collider:

commands.spawn((RigidBody::Dynamic, Collider::sphere(0.5)));

This will automatically compute the collider’s mass properties and add them to the body’s own mass properties.

By default, each collider has a density of 1.0. This can be configured with the ColliderDensity component:

commands.spawn((
    RigidBody::Dynamic,
    Collider::sphere(0.5),
    ColliderDensity(2.5),
));

If you don’t want to add a collider, you can instead add a MassPropertiesBundle with the mass properties computed from a collider shape using the MassPropertiesBundle::new_computed method.

// This is equivalent to the earlier approach, but no collider will be added
commands.spawn((
    RigidBody::Dynamic,
    MassPropertiesBundle::new_computed(&Collider::sphere(0.5), 2.5),
));

You can also specify the exact values of the mass properties by adding the components manually. To avoid the collider mass properties from being added to the body’s own mass properties, you can simply set the collider’s density to zero.

// Create a rigid body with a mass of 5.0 and a collider with no mass
commands.spawn((
    RigidBody::Dynamic,
    Collider::sphere(0.5),
    ColliderDensity(0.0),
    Mass(5.0),
    // ...the rest of the mass properties
));

See more

• Colliders
• Gravity and gravity scale
• Linear and angular velocity damping
• Lock translational and rotational axes
• Dominance
• 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,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either [TableStorage] or [SparseStorage].

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 Self: Any + Send + Sync,

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

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 Reflect>

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 Reflect>

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 Reflect>

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.

impl FromReflect for RigidBody

where Self: Any + Send + Sync,

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

Constructs a concrete instance of Self from a reflected value.

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

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

impl GetTypeRegistration for RigidBody

where Self: Any + Send + Sync,

fn get_type_registration() -> TypeRegistration

impl PartialEq for RigidBody

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Reflect for RigidBody

where Self: Any + Send + Sync,

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

Returns the [TypeInfo] of the type represented by this value.

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 reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

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

Casts this type to a mutable reflected value.

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

Clones the value as a Reflect trait object.

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

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

fn apply(&mut self, __value_param: &dyn Reflect)

Applies 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 reflect_hash(&self) -> Option<u64>

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

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

Returns a “partial equality” comparison result.

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

Debug formatter for the 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 TypePath for RigidBody

where Self: 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 Self: 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