Struct cgmath::Decomposed [] [src]

pub struct Decomposed<V: VectorSpace, R> {
    pub scale: V::Scalar,
    pub rot: R,
    pub disp: V,

A generic transformation consisting of a rotation, displacement vector and scale amount.


scale: V::Scalar rot: R disp: V

Trait Implementations

impl<V: Debug + VectorSpace, R: Debug> Debug for Decomposed<V, R> where V::Scalar: Debug

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

Formats the value using the given formatter.

impl<V: Clone + VectorSpace, R: Clone> Clone for Decomposed<V, R> where V::Scalar: Clone

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

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

impl<V: Copy + VectorSpace, R: Copy> Copy for Decomposed<V, R> where V::Scalar: Copy

impl<V: Decodable + VectorSpace, R: Decodable> Decodable for Decomposed<V, R> where V::Scalar: Decodable

fn decode<__DVR: Decoder>(__arg_0: &mut __DVR) -> Result<Decomposed<V, R>, __DVR::Error>

impl<V: Encodable + VectorSpace, R: Encodable> Encodable for Decomposed<V, R> where V::Scalar: Encodable

fn encode<__SVR: Encoder>(&self, __arg_0: &mut __SVR) -> Result<(), __SVR::Error>

impl<P: EuclideanSpace, R: Rotation<P>> Transform<P> for Decomposed<P::Diff, R> where P::Scalar: BaseFloat, P::Diff: VectorSpace

fn one() -> Decomposed<P::Diff, R>

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

fn look_at(eye: P, center: P, up: P::Diff) -> Decomposed<P::Diff, R>

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

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: &Decomposed<P::Diff, R>) -> Decomposed<P::Diff, R>

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

fn inverse_transform(&self) -> Option<Decomposed<P::Diff, R>>

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

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

Combine this transform with another, in-place.

impl<S: BaseFloat, R: Rotation2<S>> Transform2<S> for Decomposed<Vector2<S>, R>

impl<S: BaseFloat, R: Rotation3<S>> Transform3<S> for Decomposed<Vector3<S>, R>

impl<S: VectorSpace, R, E: BaseFloat> ApproxEq for Decomposed<S, R> where S: ApproxEq<Epsilon=E>, S::Scalar: ApproxEq<Epsilon=E>, R: ApproxEq<Epsilon=E>

type Epsilon = E

fn approx_eq_eps(&self, other: &Self, epsilon: &Self::Epsilon) -> bool

fn approx_epsilon() -> Self::Epsilon

fn approx_eq(&self, other: &Self) -> bool