Struct rhusics::BodyPose

pub struct BodyPose<P, R> where
    P: EuclideanSpace<Scalar = f32>,
    R: Rotation<P>,  { /* fields omitted */ }

Transform that implements Pose, and can be used as the transform component throughout the library.

Methods

impl<P, R> BodyPose<P, R> where
    P: EuclideanSpace<Scalar = f32>,
    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 clear(&mut self)

Clear the dirty flag

Trait Implementations

impl<P, R> Component for BodyPose<P, R> where
    P: EuclideanSpace<Scalar = f32> + Send + Sync + 'static,
    R: Rotation<P> + Send + Sync + 'static, 

type Storage = FlaggedStorage<Self, DenseVecStorage<Self>>

Associated storage type for this component.

impl<P: Clone, R: Clone> Clone for BodyPose<P, R> where
    P: EuclideanSpace<Scalar = f32>,
    R: Rotation<P>, 

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> where
    P: EuclideanSpace<Scalar = f32>,
    R: Rotation<P>, 

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

Formats the value using the given formatter.

impl<P, R> Transform<P> for BodyPose<P, R> where
    P: EuclideanSpace<Scalar = f32>,
    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 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<Scalar = f32>,
    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<Scalar = f32>,
    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.