Struct RigidBodyVelocity

pub struct RigidBodyVelocity {
    pub linvel: Vector<f32>,
    pub angvel: AngVector<f32>,
}

The velocities of this rigid-body.

Fields

linvel: Vector<f32>

The linear velocity of the rigid-body.

angvel: AngVector<f32>

The angular velocity of the rigid-body.

Implementations

impl RigidBodyVelocity

pub fn new(linvel: Vector<f32>, angvel: AngVector<f32>) -> Self

Create a new rigid-body velocity component.

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

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() -> Self

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) -> &Vector3<f32>

This velocity seen as a vector.

The linear part is stored first.

pub fn as_vector_mut(&mut self) -> &mut Vector3<f32>

This velocity seen as a mutable vector.

The linear part is stored first.

pub fn transformed(self, rotation: &Rotation<f32>) -> Self

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. Some physics engines call this the “mass-normalized kinetic energy”.

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

Returns the update velocities after applying the given damping.

pub fn velocity_at_point( &self, point: &Point<f32>, world_com: &Point<f32>, ) -> Vector<f32>

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

pub fn integrate( &self, dt: f32, init_pos: &Isometry<f32>, local_com: &Point<f32>, ) -> Isometry<f32>

Integrate the velocities in self to compute obtain new positions when moving from the given initial 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: Vector<f32>, )

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: Vector<f32>, point: Point<f32>, )

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 for RigidBodyVelocity

type Output = RigidBodyVelocity

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for RigidBodyVelocity

fn add_assign(&mut self, rhs: Self)

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

Formats the value using the given formatter.

impl Default for RigidBodyVelocity

fn default() -> Self

Returns the “default value” for a type.

impl From<RigidBodyVelocity> for PdErrors

fn from(vels: RigidBodyVelocity) -> Self

Converts to this type from the input type.

impl Mul<f32> for RigidBodyVelocity

type Output = RigidBodyVelocity

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq for RigidBodyVelocity

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

type Output = RigidBodyVelocity

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl SubAssign for RigidBodyVelocity

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for RigidBodyVelocity

impl StructuralPartialEq for RigidBodyVelocity