Struct rhusics_core::BodyPose

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

Transform component used throughout the library

Implementations

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

pub 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, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P, R> Interpolate<<P as EuclideanSpace>::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.

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

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P, R> Pose<P, R> for 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 rotation(&self) -> R

Borrows the rotation attribute

fn position(&self) -> P

Borrows the position attribute

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 inverse_transform_vector(&self, vec: P::Diff) -> Option<P::Diff>

Inverse 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 as EuclideanSpace>::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> StructuralPartialEq for BodyPose<P, R>