Struct cgmath::Decomposed

pub struct Decomposed<S, V, R> {
    pub scale: S,
    pub rot: R,
    pub disp: V,
}

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

Fields

scale
rot
disp

Trait Implementations

impl<S: BaseFloat, V: Vector<S>, P: Point<S, V>, R: Rotation<S, V, P>> Transform<S, V, P> for Decomposed<S, V, R>

fn identity() -> Decomposed<S, V, R>

fn look_at(eye: &P, center: &P, up: &V) -> Decomposed<S, V, R>

fn transform_vector(&self, vec: &V) -> V

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

fn concat(&self, other: &Decomposed<S, V, R>) -> Decomposed<S, V, R>

fn invert(&self) -> Option<Decomposed<S, V, R>>

fn transform_ray(&self, ray: &Ray<S, P, V>) -> Ray<S, P, V>

fn transform_as_point(&self, vec: &V) -> V

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

fn invert_self(&mut self)

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

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

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

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

impl<S: BaseFloat, V: Vector<S> + Clone, P: Point<S, V>, R: Rotation<S, V, P> + Clone> ToComponents<S, V, P, R> for Decomposed<S, V, R>

fn decompose(&self) -> (V, R, V)

impl<S: BaseFloat, R: Rotation2<S> + Clone> ToComponents2<S, R> for Decomposed<S, Vector2<S>, R>

impl<S: BaseFloat, R: Rotation3<S> + Clone> ToComponents3<S, R> for Decomposed<S, Vector3<S>, R>

impl<S: BaseFloat + 'static, R: Rotation2<S> + Clone> CompositeTransform2<S, R> for Decomposed<S, Vector2<S>, R>

impl<S: BaseFloat + 'static, R: Rotation3<S> + Clone> CompositeTransform3<S, R> for Decomposed<S, Vector3<S>, R>

Derived Implementations

impl<S: Decodable, V: Decodable, R: Decodable> Decodable for Decomposed<S, V, R>

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

impl<S: Encodable, V: Encodable, R: Encodable> Encodable for Decomposed<S, V, R>

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

impl<S: Clone, V: Clone, R: Clone> Clone for Decomposed<S, V, R>

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

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

impl<S: Copy, V: Copy, R: Copy> Copy for Decomposed<S, V, R>