Struct RigidBody 

pub struct RigidBody {

    pub body_type: BodyType,
    pub mass: f32,
    pub restitution: f32,
    pub friction: f32,
    pub linear_damping: f32,
    pub angular_damping: f32,
    pub use_gravity: bool,
    pub is_sleeping: bool,
    pub ccd_enabled: bool,
    pub local_inertia: Vec3,
    pub lock_rotation_x: bool,
    pub lock_rotation_y: bool,
    pub lock_rotation_z: bool,
    pub lock_translation_x: bool,
    pub lock_translation_y: bool,
    pub lock_translation_z: bool,
    pub sleep_counter: u32,
    pub center_of_mass: Vec3,
    pub fracture_threshold: Option<f32>,
    pub force_accumulator: Vec3,
    pub torque_accumulator: Vec3,
}

Fields

body_type: BodyType

mass: f32

restitution: f32

friction: f32

linear_damping: f32

angular_damping: f32

use_gravity: bool

is_sleeping: bool

ccd_enabled: bool

local_inertia: Vec3

lock_rotation_x: bool

lock_rotation_y: bool

lock_rotation_z: bool

lock_translation_x: bool

lock_translation_y: bool

lock_translation_z: bool

sleep_counter: u32

center_of_mass: Vec3

fracture_threshold: Option<f32>

force_accumulator: Vec3

torque_accumulator: Vec3

Implementations

impl RigidBody

pub fn new( mass: f32, restitution: f32, friction: f32, use_gravity: bool, ) -> RigidBody

pub fn new_static() -> RigidBody

pub fn new_kinematic() -> RigidBody

pub fn with_fracture_threshold(self, threshold: f32) -> RigidBody

pub fn wake_up(&mut self)

pub fn can_sleep(&self, velocity: &Velocity) -> bool

pub fn update_sleep_state(&mut self, velocity: &Velocity)

pub fn is_dynamic(&self) -> bool

pub fn is_kinematic(&self) -> bool

pub fn is_static(&self) -> bool

pub fn enforce_locks(&self, vel: &mut Velocity)

pub fn inv_mass(&self) -> f32

pub fn inv_local_inertia(&self) -> Vec3

pub fn inv_world_inertia_tensor_identity(&self) -> Mat3

Get inverse world-space inertia tensor

pub fn world_inertia_tensor(&self, rotation: Quat) -> Mat3

Get world-space inertia tensor from local inertia and rotation

pub fn inv_world_inertia_tensor(&self, rotation: Quat) -> Mat3

Get inverse world-space inertia tensor

pub fn clear_forces(&mut self)

pub fn calculate_box_inertia(&mut self, w: f32, h: f32, d: f32)

pub fn calculate_sphere_inertia(&mut self, r: f32)

pub fn calculate_capsule_inertia(&mut self, r: f32, half_h: f32)

pub fn update_inertia_from_collider(&mut self, collider: &Collider)

Trait Implementations

impl Clone for RigidBody

fn clone(&self) -> RigidBody

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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<'de> Deserialize<'de> for RigidBody

fn deserialize<__D>( __deserializer: __D, ) -> Result<RigidBody, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RigidBody

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Component for RigidBody

impl Copy for RigidBody

impl StructuralPartialEq for RigidBody