Struct rapier3d::dynamics::RigidBodyVelocity

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

The velocities of this rigid-body.

Fields

linvel: Vector<Real>

The linear velocity of the rigid-body.

angvel: AngVector<Real>

The angular velocity of the rigid-body.

Implementations

impl RigidBodyVelocity

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

Create a new rigid-body velocity component.

pub fn from_slice(slice: &[Real]) -> 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) -> &[Real]

This velocity seen as a slice.

The linear part is stored first.

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

This velocity seen as a mutable slice.

The linear part is stored first.

pub fn as_vector(&self) -> &Vector6<Real>

This velocity seen as a vector.

The linear part is stored first.

pub fn as_vector_mut(&mut self) -> &mut Vector6<Real>

This velocity seen as a mutable vector.

The linear part is stored first.

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

Return self rotated by rotation.

pub fn pseudo_kinetic_energy(&self) -> Real

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: Real, damping: &RigidBodyDamping) -> Self

Returns the update velocities after applying the given damping.

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

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

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

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) -> Real

The kinetic energy of this rigid-body.

pub fn apply_impulse( &mut self, rb_mprops: &RigidBodyMassProps, impulse: Vector<Real> )

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<Real> )

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

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<'de> Deserialize<'de> for RigidBodyVelocity

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Mul<f32> for RigidBodyVelocity

type Output = RigidBodyVelocity

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq 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 Serialize for RigidBodyVelocity

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for RigidBodyVelocity

impl StructuralPartialEq for RigidBodyVelocity