Enum heron_core::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 RigidBody where
    Self: Send + Sync + 'static, 

type Storage = TableStorage

impl Debug for RigidBody

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

Formats the value using the given formatter.

impl Default for RigidBody

fn default() -> Self

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 !=.

impl Reflect for RigidBody

fn type_name(&self) -> &str

fn any(&self) -> &dyn Any

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

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

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

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

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

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

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

Returns a hash of the value (which includes the type) if hashing is supported. Otherwise None will be returned.

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

Returns a “partial equal” comparison result if comparison is supported. Otherwise None will be returned.

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

Returns a serializable value, if serialization is supported. Otherwise None will be returned.

impl Copy for RigidBody

impl Eq for RigidBody

impl StructuralEq for RigidBody

impl StructuralPartialEq for RigidBody