Struct rapier3d::dynamics::MassProperties

pub struct MassProperties {
    pub local_com: Point<f32, U3>,
    pub inv_mass: f32,
    pub inv_principal_inertia_sqrt: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>,
    pub principal_inertia_local_frame: Unit<Quaternion<f32>>,
}

The local mass properties of a rigid-body.

Fields

local_com: Point<f32, U3>

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: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>

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

Components set to zero are assumed to be infinite along the corresponding principal axis.

principal_inertia_local_frame: Unit<Quaternion<f32>>

The principal vectors of the local angular inertia tensor of the rigid-body.

Implementations

impl MassProperties

pub fn new(
    local_com: Point<f32, U3>,
    mass: f32,
    principal_inertia: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
) -> MassProperties

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

The center-of-mass is specified in the local-space of the rigid-body. The principal angular inertia are the angular inertia along the coordinate axes in the local-space of the rigid-body.

pub fn with_principal_inertia_frame(
    local_com: Point<f32, U3>,
    mass: f32,
    principal_inertia: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>,
    principal_inertia_local_frame: Unit<Quaternion<f32>>
) -> MassProperties

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

The center-of-mass is specified in the local-space of the rigid-body. The principal angular inertia are the angular inertia along the coordinate axes defined by the principal_inertia_local_frame expressed in the local-space of the rigid-body.

pub fn with_inertia_matrix(
    local_com: Point<f32, U3>,
    mass: f32,
    inertia: Matrix<f32, U3, U3, <DefaultAllocator as Allocator<f32, U3, U3>>::Buffer>
) -> MassProperties

Initialize a new MassProperties from a given center-of-mass, mass, and angular inertia matrix.

The angular inertia matrix will be diagonalized in order to extract the principal inertia values and principal inertia frame.

pub fn world_com(
    &self,
    pos: &Isometry<f32, U3, Unit<Quaternion<f32>>>
) -> Point<f32, U3>

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

pub fn world_inv_inertia_sqrt(
    &self,
    rot: &Unit<Quaternion<f32>>
) -> SdpMatrix3<f32>

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

pub fn reconstruct_inverse_inertia_matrix(
    &self
) -> Matrix<f32, U3, U3, <DefaultAllocator as Allocator<f32, U3, U3>>::Buffer>

Reconstructs the inverse angular inertia tensor of the rigid body from its principal inertia values and axes.

pub fn reconstruct_inertia_matrix(
    &self
) -> Matrix<f32, U3, U3, <DefaultAllocator as Allocator<f32, U3, U3>>::Buffer>

Reconstructs the angular inertia tensor of the rigid body from its principal inertia values and axes.

pub fn transform_by(
    &self,
    m: &Isometry<f32, U3, Unit<Quaternion<f32>>>
) -> 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: Point<f32, U3>,
    b: Point<f32, U3>,
    radius: f32
) -> MassProperties

Computes the mass properties of a capsule.

impl MassProperties

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

Computes the mass properties of a compound shape.

impl MassProperties

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

Computes the mass properties of a cone.

impl MassProperties

pub fn from_convex_polyhedron(
    density: f32,
    vertices: &[Point<f32, U3>],
    indices: &[[u32; 3]]
) -> MassProperties

Computes the mass properties of a convex polyhedron.

impl MassProperties

pub fn from_cuboid(
    density: f32,
    half_extents: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
) -> MassProperties

Computes the mass properties of a cuboid.

impl MassProperties

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

Computes the mass properties of a cylinder.

Trait Implementations

impl AbsDiffEq<MassProperties> for MassProperties

type Epsilon = f32

Used for specifying relative comparisons.

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

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

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

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

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

The inverse of AbsDiffEq::abs_diff_eq.

impl Add<MassProperties> for MassProperties

type Output = MassProperties

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<MassProperties> for MassProperties

pub fn add_assign(&mut self, rhs: MassProperties)

Performs the += operation.

impl Clone for MassProperties

pub fn clone(&self) -> MassProperties

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for MassProperties

impl Debug for MassProperties

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

Formats the value using the given formatter.

impl PartialEq<MassProperties> for MassProperties

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

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

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

This method tests for !=.

impl RelativeEq<MassProperties> for MassProperties

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

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

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

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

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

The inverse of RelativeEq::relative_eq.

impl StructuralPartialEq for MassProperties

impl Sub<MassProperties> for MassProperties

type Output = MassProperties

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<MassProperties> for MassProperties

pub fn sub_assign(&mut self, rhs: MassProperties)

Performs the -= operation.

impl Sum<MassProperties> for MassProperties

pub fn sum<I>(iter: I) -> MassProperties where
    I: Iterator<Item = MassProperties>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Zero for MassProperties

pub fn zero() -> MassProperties

Returns the additive identity element of Self, 0.

pub fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

pub fn set_zero(&mut self)

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