Struct RigidBodyVelocity 

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

The velocities of this rigid-body.

Fields

linvel: Vector<T>

The linear velocity of the rigid-body.

angvel: AngVector<T>

The angular velocity of the rigid-body.

Implementations

impl RigidBodyVelocity<f32>

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 6 elements: the slice[0..3] contains the linear velocity and the slice[3..6] 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) -> &Vector6<f32>

This velocity seen as a vector.

The linear part is stored first.

pub fn as_vector_mut(&mut self) -> &mut Vector6<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 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 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: Vector<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.

impl<T: SimdRealCopy> RigidBodyVelocity<T>

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

Returns the update velocities after applying the given damping.

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

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

pub fn integrate_centered(&self, dt: T, pose: Isometry<T>) -> Isometry<T>

Same as Self::integrate but with a local center-of-mass assumed to be zero.

pub fn integrate_linearized(&self, dt: T, pose: &mut Isometry<T>)

Same as Self::integrate but with the angular part linearized and the local center-of-mass assumed to be zero.

Trait Implementations

impl Add for RigidBodyVelocity<f32>

type Output = RigidBodyVelocity<f32>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for RigidBodyVelocity<f32>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + SimdRealCopy> Clone for RigidBodyVelocity<T>

fn clone(&self) -> RigidBodyVelocity<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + SimdRealCopy> Debug for RigidBodyVelocity<T>

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

Formats the value using the given formatter.

impl Default for RigidBodyVelocity<f32>

fn default() -> Self

Returns the “default value” for a type.

impl From<RigidBodyVelocity<f32>> for PdErrors

fn from(vels: RigidBodyVelocity<f32>) -> Self

Converts to this type from the input type.

impl Mul<f32> for RigidBodyVelocity<f32>

type Output = RigidBodyVelocity<f32>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: PartialEq + SimdRealCopy> PartialEq for RigidBodyVelocity<T>

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

type Output = RigidBodyVelocity<f32>

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for RigidBodyVelocity<f32>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy + SimdRealCopy> Copy for RigidBodyVelocity<T>

impl<T: SimdRealCopy> StructuralPartialEq for RigidBodyVelocity<T>