Struct Transform 

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

Fields

position: V

orientation: R

Implementations

impl<V, R> Transform<V, R>

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

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

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

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

Trait Implementations

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

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

type Output = Transform<V, R>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

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

Performs the += operation.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

type Output = Transform<V, R>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

fn div_assign(&mut self, other: Self)

Performs the /= operation.

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

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

type Output = Transform<V, R>

fn inv(self) -> Self

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

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

type Output = Transform<V, R>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

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

fn one() -> Self

fn is_one(&self) -> bool

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

fn eq(&self, other: &Transform<V, 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<V, R, B> Sub<Movement<V, B>> for Transform<V, R>

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

type Output = Transform<V, R>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

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

Performs the -= operation.

impl<V, R> Transform<V> for Transform<V, R>

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

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

Applies this transformation to a point.

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

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

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