Struct RigidBody

Source

pub struct RigidBody {Show 21 fields
    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

Struct RigidBody Copy item path

Fields§

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

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

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

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

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

impl Component for RigidBody

fn storage_type() -> StorageType

impl Debug for RigidBody

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

impl Default for RigidBody

fn default() -> RigidBody

impl<'de> Deserialize<'de> for RigidBody

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

type This<'from_arg> = &'from_arg RigidBody

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static RigidBody as FromArg>::This<'_>, ArgError>

type This<'from_arg> = &'from_arg mut RigidBody

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static mut RigidBody as FromArg>::This<'_>, ArgError>

type This<'from_arg> = RigidBody

fn from_arg(arg: Arg<'_>) -> Result<<RigidBody as FromArg>::This<'_>, ArgError>

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<RigidBody>

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

fn ownership() -> Ownership

fn ownership() -> Ownership

fn ownership() -> Ownership

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

fn into_return<'into_return>(self) -> Return<'into_return>where &RigidBody: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>where &mut RigidBody: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>where RigidBody: 'into_return,

impl PartialEq for RigidBody

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

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

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

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

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

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

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

fn reflect_owned(self: Box<RigidBody>) -> ReflectOwned

fn try_into_reflect( self: Box<RigidBody>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

fn into_partial_reflect(self: Box<RigidBody>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

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

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

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

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

fn is_dynamic(&self) -> bool

fn into_any(self: Box<RigidBody>) -> Box<dyn Any>

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

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

fn into_reflect(self: Box<RigidBody>) -> Box<dyn Reflect>

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

Struct RigidBody

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

fn into_return<'into_return>(self) -> Return<'into_return>
where &RigidBody: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>
where &mut RigidBody: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>
where RigidBody: 'into_return,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer,

impl TypePath for RigidBody
where RigidBody: Any + Send + Sync,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> Bundle for T
where T: Component,

impl<T> BundleExt for T
where T: Bundle,

fn with<C>(self, component: C) -> DynamicBundle<Self, C>
where C: Component,

impl<T> CloneToUninit for T
where T: Clone,