Struct Transform 

pub struct Transform<P, R> {
    pub position: P,
    pub orientation: R,
}

Fields

position: P

orientation: R

Implementations

impl<P, R> Transform<P, R>

where P: Clone + AffineSpace + Add<P::Diff, Output = P>, P::Diff: VectorSpace, R: Clone + AffineSpace + Add<R::Diff, Output = R>, R::Diff: VectorSpace<Scalar = <P::Diff as VectorSpace>::Scalar>,

pub fn lerp( &self, other: &Self, ratio: <P::Diff as VectorSpace>::Scalar, ) -> Self

impl<P: Copy + Add<Output = P>, R: Transform<P>> Transform<P, R>

pub fn apply(&self, point: P) -> P

Trait Implementations

impl<P, R, V, B> Add<Movement<V, B>> for Transform<P, R>

where P: Add<V, Output = P>, B: Exp<Output = R>, R: Mul<Output = R>,

type Output = Transform<P, R>

The resulting type after applying the + operator.

fn add(self, movement: Movement<V, B>) -> Self

Performs the + operation.

impl<P, R, V, B> AddAssign<Movement<V, B>> for Transform<P, R>

where P: AddAssign<V>, B: Exp<Output = R>, R: MulAssign,

fn add_assign(&mut self, movement: Movement<V, B>)

Performs the += operation.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<P, R> Div for Transform<P, R>

where P: Add<Output = P> + Neg<Output = P>, R: Copy + Mul<Output = R> + Inv<Output = R> + Transform<P>,

type Output = Transform<P, R>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl<P, R> DivAssign for Transform<P, R>

where P: SubAssign, R: Copy + DivAssign + Transform<P>,

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<P, R> Inv for Transform<P, R>

where P: Neg<Output = P>, R: Copy + Inv<Output = R> + Transform<P>,

type Output = Transform<P, R>

fn inv(self) -> Self

impl<P, R> Mul for Transform<P, R>

where P: Add<Output = P>, R: Copy + Mul<Output = R> + Transform<P>,

type Output = Transform<P, R>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<P, R> MulAssign for Transform<P, R>

where P: AddAssign, R: Copy + MulAssign + Transform<P>,

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<P: Zero, R: One> One for Transform<P, R>

fn one() -> Self

fn is_one(&self) -> bool

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<P, R, V, B> Sub<Movement<V, B>> for Transform<P, R>

where P: Sub<V, Output = P>, B: Exp<Output = R>, R: Div<Output = R>,

type Output = Transform<P, R>

The resulting type after applying the - operator.

fn sub(self, movement: Movement<V, B>) -> Self

Performs the - operation.

impl<P, R, V, B> SubAssign<Movement<V, B>> for Transform<P, R>

where P: SubAssign<V>, B: Exp<Output = R>, R: DivAssign,

fn sub_assign(&mut self, movement: Movement<V, B>)

Performs the -= operation.

impl<P, R> Transform<P> for Transform<P, R>

where P: Copy + Add<Output = P>, R: Transform<P>,

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

Applies this transformation to a point.

impl<P: Copy, R: Copy> Copy for Transform<P, R>

impl<P: Eq, R: Eq> Eq for Transform<P, R>

impl<P, R> StructuralPartialEq for Transform<P, R>