Struct rhusics::BodyPose

pub struct BodyPose<P, R> { /* fields omitted */ }

Transform component used throughout the library

Methods

impl<P, R> BodyPose<P, R> where
    P: EuclideanSpace,
    P::Scalar: BaseFloat,
    R: Rotation<P>, 

fn new(position: P, rotation: R) -> Self

Create a new BodyPose with initial state given by the supplied position and rotation.

fn set_rotation(&mut self, rotation: R)

Set the rotation. Will also compute the inverse rotation. Sets the dirty flag.

fn set_position(&mut self, position: P)

Set the position. Sets the dirty flag.

fn position(&self) -> &P

Borrows the position attribute

fn rotation(&self) -> &R

Borrows the rotation attribute

fn clear(&mut self)

Clear the dirty flag

Trait Implementations

impl<P: Clone, R: Clone> Clone for BodyPose<P, R>

fn clone(&self) -> BodyPose<P, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug, R: Debug> Debug for BodyPose<P, R>

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

Formats the value using the given formatter.

impl<P: PartialEq, R: PartialEq> PartialEq for BodyPose<P, R>

fn eq(&self, __arg_0: &BodyPose<P, R>) -> bool

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

fn ne(&self, __arg_0: &BodyPose<P, R>) -> bool

This method tests for !=.

impl<P, R> Transform<P> for BodyPose<P, R> where
    P: EuclideanSpace,
    P::Scalar: BaseFloat,
    R: Rotation<P>, 

fn one() -> Self

Create an identity transformation. That is, a transformation which does nothing.

fn look_at(eye: P, center: P, up: P::Diff) -> Self

Create a transformation that rotates a vector to look at center from eye, using up for orientation.

fn transform_vector(&self, vec: P::Diff) -> P::Diff

Transform a vector using this transform.

fn transform_point(&self, point: P) -> P

Transform a point using this transform.

fn concat(&self, other: &Self) -> Self

Combine this transform with another, yielding a new transformation which has the effects of both.

fn inverse_transform(&self) -> Option<Self>

Create a transform that "un-does" this one.

fn inverse_transform_vector(&self, vec: P::Diff) -> Option<P::Diff>

Inverse transform a vector using this transform

fn concat_self(&mut self, other: &Self)

Combine this transform with another, in-place.

impl<P, R> TranslationInterpolate<P::Scalar> for BodyPose<P, R> where
    P: EuclideanSpace,
    P::Scalar: BaseFloat,
    P::Diff: VectorSpace + InnerSpace,
    R: Rotation<P> + Clone, 

fn translation_interpolate(&self, other: &Self, amount: P::Scalar) -> Self

Interpolate between self and other, using amount to calculate how much of other to use.

impl<P, R> Interpolate<P::Scalar> for BodyPose<P, R> where
    P: EuclideanSpace,
    P::Scalar: BaseFloat,
    P::Diff: VectorSpace + InnerSpace,
    R: Rotation<P> + Interpolate<P::Scalar>, 

fn interpolate(&self, other: &Self, amount: P::Scalar) -> Self

Interpolate between self and other, using amount to calculate how much of other to use.