Struct rhusics_core::Velocity

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

Velocity

Type parameters:

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

Methods

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn linear(&self) -> &L

Get linear velocity

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

Set angular velocity

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn angular(&self) -> &A

Get angular velocity

pub fn apply<B, P, R>(&self, pose: &B, dt: L::Scalar) -> B where     P: EuclideanSpace<Scalar = L::Scalar, Diff = L>,     L: VectorSpace,     L::Scalar: BaseFloat,     R: ApplyAngular<L::Scalar, A> + Rotation<P>,     B: Pose<P, R>,

Apply velocity to pose.

Parameters:

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

Type parameters:

• B: Transform type (BodyPose3 or similar)
• 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: Debug, A: Debug> Debug for Velocity<L, A>

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

Formats the value using the given formatter.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

fn eq(&self, other: &Velocity<L, A>) -> bool

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

fn ne(&self, other: &Velocity<L, A>) -> bool

This method tests for !=.

impl<L, A> Default for Velocity<L, A> where     L: Zero,     A: Clone + Zero,

fn default() -> Self

Returns the "default value" for a type.