Struct MassProperties

pub struct MassProperties {
    pub local_com: OPoint<f32, Const<2>>,
    pub inv_mass: f32,
    pub inv_principal_inertia_sqrt: f32,
}

The local mass properties of a rigid-body.

Fields

local_com: OPoint<f32, Const<2>>

The center of mass of a rigid-body expressed in its local-space.

inv_mass: f32

The inverse of the mass of a rigid-body.

If this is zero, the rigid-body is assumed to have infinite mass.

inv_principal_inertia_sqrt: f32

The inverse of the principal angular inertia of the rigid-body.

The angular inertia is calculated relative to Self::local_com. Components set to zero are assumed to be infinite along the corresponding principal axis.

Implementations

impl MassProperties

pub fn new( local_com: OPoint<f32, Const<2>>, mass: f32, principal_inertia: f32, ) -> MassProperties

Initializes the mass properties with the given center-of-mass, mass, and angular inertia.

The center-of-mass is specified in the local-space of the rigid-body.

pub fn mass(&self) -> f32

The mass.

pub fn principal_inertia(&self) -> f32

The angular inertia along the principal inertia axes and center of mass of the rigid-body.

pub fn world_com( &self, pos: &Isometry<f32, Unit<Complex<f32>>, 2>, ) -> OPoint<f32, Const<2>>

The world-space center of mass of the rigid-body.

pub fn world_inv_inertia_sqrt(&self, _rot: &Unit<Complex<f32>>) -> f32

The world-space inverse angular inertia tensor of the rigid-body.

pub fn transform_by( &self, m: &Isometry<f32, Unit<Complex<f32>>, 2>, ) -> MassProperties

Transform each element of the mass properties.

pub fn set_mass(&mut self, new_mass: f32, adjust_angular_inertia: bool)

Changes the mass on these mass-properties.

The adjust_angular_inertia argument should always be true, unless there are some specific reasons not to do so. Setting this to true will automatically adjust the angular inertia of self to account for the mass change (i.e. it will multiply the angular inertia by new_mass / prev_mass). Setting it to false will not change the current angular inertia.

impl MassProperties

pub fn from_ball(density: f32, radius: f32) -> MassProperties

Computes the mass properties of a ball.

impl MassProperties

pub fn from_capsule( density: f32, a: OPoint<f32, Const<2>>, b: OPoint<f32, Const<2>>, radius: f32, ) -> MassProperties

Computes the mass properties of a capsule.

impl MassProperties

pub fn from_compound( density: f32, shapes: &[(Isometry<f32, Unit<Complex<f32>>, 2>, SharedShape)], ) -> MassProperties

Computes the mass properties of a compound shape.

impl MassProperties

pub fn from_convex_polygon( density: f32, vertices: &[OPoint<f32, Const<2>>], ) -> MassProperties

Computes the mass properties of a convex polygon.

impl MassProperties

pub fn from_cuboid( density: f32, half_extents: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, ) -> MassProperties

Computes the mass properties of a cuboid.

impl MassProperties

pub fn from_triangle( density: f32, a: &OPoint<f32, Const<2>>, b: &OPoint<f32, Const<2>>, c: &OPoint<f32, Const<2>>, ) -> MassProperties

Computes the mass properties of a triangle.

impl MassProperties

pub fn from_trimesh( density: f32, vertices: &[OPoint<f32, Const<2>>], indices: &[[u32; 3]], ) -> MassProperties

Computes the mass properties of a triangle-mesh.

Trait Implementations

impl AbsDiffEq for MassProperties

type Epsilon = f32

Used for specifying relative comparisons.

fn default_epsilon() -> <MassProperties as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq( &self, other: &MassProperties, epsilon: <MassProperties as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl Add for MassProperties

type Output = MassProperties

The resulting type after applying the + operator.

fn add(self, other: MassProperties) -> MassProperties

Performs the + operation.

impl AddAssign for MassProperties

fn add_assign(&mut self, rhs: MassProperties)

Performs the += operation.

impl Clone for MassProperties

fn clone(&self) -> MassProperties

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MassProperties

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

Formats the value using the given formatter.

impl Default for MassProperties

fn default() -> MassProperties

Returns the “default value” for a type.

impl From<MassProperties> for ColliderMassProps

fn from(mprops: MassProperties) -> Self

Converts to this type from the input type.

impl From<MassProperties> for RigidBodyMassProps

fn from(local_mprops: MassProperties) -> Self

Converts to this type from the input type.

impl PartialEq for MassProperties

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

fn default_max_relative() -> <MassProperties as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &MassProperties, epsilon: <MassProperties as AbsDiffEq>::Epsilon, max_relative: <MassProperties as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl Sub for MassProperties

type Output = MassProperties

The resulting type after applying the - operator.

fn sub(self, other: MassProperties) -> MassProperties

Performs the - operation.

impl SubAssign for MassProperties

fn sub_assign(&mut self, rhs: MassProperties)

Performs the -= operation.

impl Sum for MassProperties

fn sum<I>(iter: I) -> MassProperties

where I: Iterator<Item = MassProperties>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Zero for MassProperties

fn zero() -> MassProperties

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Copy for MassProperties

impl StructuralPartialEq for MassProperties