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.

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.