Struct Velocity 

pub struct Velocity<L, A> { /* private fields */ }

Velocity

Type parameters:

• L: Linear velocity, usually Vector2 or Vector3
• A: Angular velocity, usually Scalar or Vector3

Implementations

impl<L, A> Velocity<L, A>

where L: Zero, A: Clone + Zero,

pub fn new(linear: L, angular: A) -> Self

Create new velocity object, with both linear and angular velocity

pub fn from_linear(linear: L) -> Self

Create new velocity object with only linear velocity

pub fn set_linear(&mut self, linear: L)

Set linear velocity

pub fn linear(&self) -> &L

Get linear velocity

pub fn set_angular(&mut self, angular: A)

Set angular velocity

pub fn angular(&self) -> &A

Get angular velocity

pub fn apply<P, R>( &self, pose: &BodyPose<P, R>, dt: L::Scalar, ) -> BodyPose<P, R>

where P: EuclideanSpace<Scalar = L::Scalar, Diff = L>, L: VectorSpace, L::Scalar: BaseFloat, R: ApplyAngular<L::Scalar, A> + Rotation<P>,

Apply velocity to pose.

Parameters:

• pose: Pose to apply the velocity to
• dt: Time step

Type parameters:

• P: Positional quantity, usually Point2 or Point3
• R: Rotational quantity, usually Basis2 or Quaternion

pub fn apply_linear<P>(&self, linear: &P, dt: L::Scalar) -> P

where P: EuclideanSpace<Scalar = L::Scalar, Diff = L>, L::Scalar: BaseFloat, L: VectorSpace,

Apply linear velocity to a positional quantity

Parameters:

• linear: Positional value
• dt: Time step

Type parameters:

• P: Positional quantity, usually Point2 or Point3

pub fn apply_angular<R>(&self, rotation: &R, dt: L::Scalar) -> R

where R: ApplyAngular<L::Scalar, A>, L: VectorSpace, L::Scalar: BaseFloat,

Apply angular velocity to a rotational quantity

Parameters:

• rotation: Rotational value
• dt: Time step

Type parameters:

• R: Rotational quantity, usually Basis2 or Quaternion

Trait Implementations

impl<L: Clone, A: Clone> Clone for Velocity<L, A>

fn clone(&self) -> Velocity<L, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug, A: Debug> Debug for Velocity<L, A>

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

Formats the value using the given formatter.

impl<L, A> Default for Velocity<L, A>

where L: Zero, A: Clone + Zero,

fn default() -> Self

Returns the “default value” for a type.

impl<L: PartialEq, A: PartialEq> PartialEq for Velocity<L, A>

fn eq(&self, other: &Velocity<L, A>) -> 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<L, A> StructuralPartialEq for Velocity<L, A>