Struct heron::rapier_plugin::rapier2d::prelude::RigidBodyVelocity

pub struct RigidBodyVelocity {
    pub linvel: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>,
    pub angvel: f32,
}

The velocities of this rigid-body.

Fields

linvel: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>

The linear velocity of the rigid-body.

angvel: f32

The angular velocity of the rigid-body.

Implementations

impl RigidBodyVelocity

pub fn new(
    linvel: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>,
    angvel: f32
) -> RigidBodyVelocity

Create a new rigid-body velocity component.

pub fn from_slice(slice: &[f32]) -> RigidBodyVelocity

Converts a slice to a rigid-body velocity.

The slice must contain at least 3 elements: the slice[0..2] contains the linear velocity and the slice[2]` contains the angular velocity.

pub fn zero() -> RigidBodyVelocity

Velocities set to zero.

pub fn as_slice(&self) -> &[f32]

This velocity seen as a slice.

The linear part is stored first.

pub fn as_mut_slice(&mut self) -> &mut [f32]

This velocity seen as a mutable slice.

The linear part is stored first.

pub fn as_vector(
    &self
) -> &Matrix<f32, Const<3>, Const<1>, ArrayStorage<f32, 3, 1>>

This velocity seen as a vector.

The linear part is stored first.

pub fn as_vector_mut(
    &mut self
) -> &mut Matrix<f32, Const<3>, Const<1>, ArrayStorage<f32, 3, 1>>

This velocity seen as a mutable vector.

The linear part is stored first.

pub fn transformed(self, rotation: &Unit<Complex<f32>>) -> RigidBodyVelocity

Return self rotated by rotation.

pub fn pseudo_kinetic_energy(&self) -> f32

The approximate kinetic energy of this rigid-body.

This approximation does not take the rigid-body’s mass and angular inertia into account.

pub fn apply_damping(
    &self,
    dt: f32,
    damping: &RigidBodyDamping
) -> RigidBodyVelocity

Returns the update velocities after applying the given damping.

pub fn velocity_at_point(
    &self,
    point: &OPoint<f32, Const<2>>,
    world_com: &OPoint<f32, Const<2>>
) -> Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>

The velocity of the given world-space point on this rigid-body.

pub fn integrate(
    &self,
    dt: f32,
    init_pos: &Isometry<f32, Unit<Complex<f32>>, 2>,
    local_com: &OPoint<f32, Const<2>>
) -> Isometry<f32, Unit<Complex<f32>>, 2>

Integrate the velocities in self to compute obtain new positions when moving from the given inital position init_pos.

pub fn is_zero(&self) -> bool

Are these velocities exactly equal to zero?

pub fn kinetic_energy(&self, rb_mprops: &RigidBodyMassProps) -> f32

The kinetic energy of this rigid-body.

pub fn apply_impulse(
    &mut self,
    rb_mprops: &RigidBodyMassProps,
    impulse: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>
)

Applies an impulse at the center-of-mass of this rigid-body. The impulse is applied right away, changing the linear velocity. This does nothing on non-dynamic bodies.

pub fn apply_torque_impulse(
    &mut self,
    rb_mprops: &RigidBodyMassProps,
    torque_impulse: f32
)

Applies an angular impulse at the center-of-mass of this rigid-body. The impulse is applied right away, changing the angular velocity. This does nothing on non-dynamic bodies.

pub fn apply_impulse_at_point(
    &mut self,
    rb_mprops: &RigidBodyMassProps,
    impulse: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>,
    point: OPoint<f32, Const<2>>
)

Applies an impulse at the given world-space point of this rigid-body. The impulse is applied right away, changing the linear and/or angular velocities. This does nothing on non-dynamic bodies.

Trait Implementations

impl Add<RigidBodyVelocity> for RigidBodyVelocity

type Output = RigidBodyVelocity

The resulting type after applying the + operator.

fn add(self, rhs: RigidBodyVelocity) -> RigidBodyVelocity

Performs the + operation.

impl AddAssign<RigidBodyVelocity> for RigidBodyVelocity

fn add_assign(&mut self, rhs: RigidBodyVelocity)

Performs the += operation.

impl Clone for RigidBodyVelocity

fn clone(&self) -> RigidBodyVelocity

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RigidBodyVelocity

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

Formats the value using the given formatter.

impl Default for RigidBodyVelocity

fn default() -> RigidBodyVelocity

Returns the “default value” for a type.

impl Mul<f32> for RigidBodyVelocity

type Output = RigidBodyVelocity

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> RigidBodyVelocity

Performs the * operation.

impl PartialEq<RigidBodyVelocity> for RigidBodyVelocity

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for RigidBodyVelocity

impl StructuralPartialEq for RigidBodyVelocity