Struct Friction

pub struct Friction {
    pub dynamic_coefficient: Scalar,
    pub static_coefficient: Scalar,
    pub combine_rule: CoefficientCombine,
}

A component for dry friction, controlling how strongly a rigid body or collider opposes sliding along other surfaces while in contact.

For surfaces that are at rest relative to each other, static friction is used. Once the static friction is overcome, the bodies will start sliding, and dynamic friction is applied instead. The friction force is proportional to the normal force of the contact, following the Coulomb friction model.

The friction coefficients should typically be between 0 and 1, where 0 corresponds to no friction at all, and 1 corresponds to high friction. However, any non-negative value is allowed.

If a collider does not have Friction specified, the Friction of its rigid body entity will be used instead. If that is not specified either, collisions use the DefaultFriction resource. The default dynamic and static friction coefficients are set to 0.5.

Combine Rule

When two bodies collide, their coefficients are combined using the specified CoefficientCombine rule. In the case of clashing rules, the following priority order is used: Max > Multiply > Min > GeometricMean > Average.

By default, friction uses CoefficientCombine::Average, computing the average (a + b) / 2.0.

Usage

Create a new Friction component with dynamic and static friction coefficients of 0.4:

Friction::new(0.4)

Set the other friction coefficient:

// 0.4 static and 0.6 dynamic
Friction::new(0.4).with_dynamic_coefficient(0.6)
// 0.4 dynamic and 0.6 static
Friction::new(0.4).with_static_coefficient(0.6)

Configure how the friction coefficients of two Friction components are combined with CoefficientCombine:

Friction::new(0.4).with_combine_rule(CoefficientCombine::Multiply)

Combine the properties of two Friction components:

let first = Friction::new(0.8).with_combine_rule(CoefficientCombine::Average);
let second = Friction::new(0.5).with_combine_rule(CoefficientCombine::Multiply);

// `CoefficientCombine::Multiply` has higher priority, so the coefficients are multiplied
assert_eq!(
    first.combine(second),
    Friction::new(0.4).with_combine_rule(CoefficientCombine::Multiply)
);

Accuracy

Avian attempts to simulate friction accurately, but Coulomb friction is still a simplification of real-world friction. Each collision typically has only a small number of contact points, so friction cannot consider the entire surface perfectly. Still, friction should be reasonably accurate for most cases, particularly for game purposes.

It is worth noting that in real life, friction coefficients can vary greatly based on material combinations, surface roughness, and numerous other factors, and they are not uniform across surfaces. For game purposes however, it is impractical to consider all of these factors, so instead, material interactions are controlled using simple CoefficientCombine rules.

Fields

dynamic_coefficient: Scalar

Coefficient of dynamic friction. Applied when bodies are sliding relative to each other.

Defaults to 0.5.

static_coefficient: Scalar

Coefficient of static friction. Applied when bodies are at rest relative to each other.

Defaults to 0.5.

combine_rule: CoefficientCombine

The rule used for computing the combined coefficients of friction when two bodies collide.

Defaults to CoefficientCombine::Average.

Implementations

impl Friction

pub const ZERO: Self = _

Zero dynamic and static friction and CoefficientCombine::Average.

pub fn new(friction_coefficient: Scalar) -> Self

Creates a new Friction component with the same dynamic and static friction coefficients.

pub fn with_combine_rule(&self, combine_rule: CoefficientCombine) -> Self

Sets the CoefficientCombine rule used.

pub fn with_dynamic_coefficient(&self, coefficient: Scalar) -> Self

Sets the coefficient of dynamic friction.

pub fn with_static_coefficient(&self, coefficient: Scalar) -> Self

Sets the coefficient of static friction.

pub fn combine(&self, other: Self) -> Self

Combines the properties of two Friction components.

Trait Implementations

impl Clone for Friction

fn clone(&self) -> Friction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Friction

where Self: Send + Sync + 'static,

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 Friction

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

Formats the value using the given formatter.

impl Default for Friction

fn default() -> Self

The default Friction with dynamic and static friction coefficients of 0.5 and a combine rule of CoefficientCombine::Average.

impl From<f32> for Friction

fn from(coefficient: Scalar) -> Self

Converts to this type from the input type.

impl FromReflect for Friction

where Friction: Any + Send + Sync, Scalar: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CoefficientCombine: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &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 Friction

where Friction: Any + Send + Sync, Scalar: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CoefficientCombine: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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 Friction

fn eq(&self, other: &Friction) -> 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 PartialOrd for Friction

fn partial_cmp(&self, other: &Friction) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialReflect for Friction

where Friction: Any + Send + Sync, Scalar: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CoefficientCombine: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

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

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 Friction

where Friction: Any + Send + Sync, Scalar: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CoefficientCombine: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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 Struct for Friction

where Friction: Any + Send + Sync, Scalar: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CoefficientCombine: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Returns a reference to the value of the field named name as a &dyn PartialReflect.

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

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

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

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

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

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

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

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for Friction

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

where Friction: Any + Send + Sync, Scalar: FromReflect + TypePath + MaybeTyped + RegisterForReflection, CoefficientCombine: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Friction

impl StructuralPartialEq for Friction