Enum heron_core::BodyType

pub enum BodyType {
    Dynamic,
    Static,
    Kinematic,
    Sensor,
}

Component that defines the type of rigid body.

Example

fn spawn(mut commands: Commands, mut materials: ResMut<Assets<ColorMaterial>>) {
    commands.spawn_bundle(todo!("Spawn your sprite/mesh, incl. at least a GlobalTransform"))
        .insert(Body::Sphere { radius: 1.0 }) // Make a body (is dynamic by default)
        .insert(BodyType::Static); // Make it static (so that it doesn't move and is not affected by forces like gravity)
}

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.

Kinematic

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 transform is updated, then a velocity will be automatically calculated, producing realistic interaction with other bodies.

It can also have a velocity be applied.

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 BodyType

#[must_use]

pub fn can_have_velocity(self) -> bool

Returns true if this body type can be moved by Velocity

Trait Implementations

impl Clone for BodyType

fn clone(&self) -> BodyType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for BodyType

impl Debug for BodyType

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

Formats the value using the given formatter.

impl Default for BodyType

fn default() -> Self

Returns the “default value” for a type.

impl Eq for BodyType

impl GetTypeRegistration for BodyType

fn get_type_registration() -> TypeRegistration

impl PartialEq<BodyType> for BodyType

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

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

#[must_use]

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

This method tests for !=.

impl Reflect for BodyType

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 StructuralEq for BodyType

impl StructuralPartialEq for BodyType