Enum heron::prelude::RigidBody

pub enum RigidBody {
    Dynamic,
    Static,
    KinematicPositionBased,
    KinematicVelocityBased,
    Sensor,
}

Component that mark the entity as being a rigid body

It’ll need some CollisionShape to be attached. Either in the same entity or in a direct child

Example

fn spawn(mut commands: Commands) {
    commands.spawn_bundle(todo!("Spawn your sprite/mesh, incl. at least a GlobalTransform"))
        .insert(RigidBody::Dynamic) // Create a dynamic rigid body
        .insert(CollisionShape::Sphere { radius: 1.0 }); // Attach a collision shape
}

Variants

Dynamic

A dynamic body is normally affected by physic forces and affect the other bodies normally too.

This is the most “natural” type in the sense that, in real life, everything is dynamic.

It is the default type.

Static

A static body is not affected by physic forces and doesn’t move. But it does affect the other bodies.

This effectively behaves like a dynamic body with infinite mass and zero velocity.

It is well suited for terrain and static obstacles.

KinematicPositionBased

A kinematic body is not moved by the physics engine. But it can have user-defined position.

It affects the other bodies normally but is not affected by them.

If the transform is updated, then a velocity will be automatically calculated, producing realistic interaction with other bodies.

It is well-suited for moving platforms.

KinematicVelocityBased

A kinematic body is not moved by the physics engine. But it can have user-defined velocity.

It affects the other bodies normally but is not affected by them.

If the velocity is updated, then a velocity will produce realistic interaction with other bodies.

It is well-suited for moving platforms.

Sensor

A sensor is not affected by physics forces and doesn’t affect other bodies either.

Other bodies will be able to penetrate the sensor. But it still participates in collision events.

A sensor is useful when we are only interested in collision events. One may, for example, add a sensor to detect when the player reaches a certain area.

Implementations

impl RigidBody

pub fn can_have_velocity(self) -> bool

Returns true if this body type can be moved by Velocity

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 RigidBodywhere
    RigidBody: 'static + Send + Sync,

type Storage = TableStorage

impl Debug for RigidBody

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

Formats the value using the given formatter.

impl Default for RigidBody

fn default() -> RigidBody

Returns the “default value” for a type.

impl GetTypeRegistration for RigidBody

fn get_type_registration() -> TypeRegistration

impl PartialEq<RigidBody> 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

fn type_name(&self) -> &str

Returns the type name of the underlying type.

fn get_type_info(&self) -> &'static TypeInfo

Returns the [TypeInfo] of the underlying type.

fn into_any(self: Box<RigidBody, Global>) -> Box<dyn Any + 'static, Global>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value

fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

Clones the value as a Reflect trait object.

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

Applies a reflected value to this value.

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

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

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

Returns an enumeration of “kinds” of type.

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

Returns a mutable 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 + 'static)) -> 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.

impl Typed for RigidBody

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for RigidBody

impl Eq for RigidBody

impl StructuralEq for RigidBody

impl StructuralPartialEq for RigidBody