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, 

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

Create new velocity object, with both linear and angular velocity

fn from_linear(linear: L) -> Self

Create new velocity object with only linear velocity

fn set_linear(&mut self, linear: L)

Set linear velocity

fn linear(&self) -> &L

Get linear velocity

fn set_angular(&mut self, angular: A)

Set angular velocity

fn angular(&self) -> &A

Get angular velocity

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

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

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, __arg_0: &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, __arg_0: &Velocity<L, A>) -> bool

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

fn ne(&self, __arg_0: &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.