[−][src]Struct euclid::TypedTransform3D

#[repr(C)]
pub struct TypedTransform3D<T, Src, Dst> {
    pub m11: T,
    pub m12: T,
    pub m13: T,
    pub m14: T,
    pub m21: T,
    pub m22: T,
    pub m23: T,
    pub m24: T,
    pub m31: T,
    pub m32: T,
    pub m33: T,
    pub m34: T,
    pub m41: T,
    pub m42: T,
    pub m43: T,
    pub m44: T,
    // some fields omitted
}

A 3d transform stored as a 4 by 4 matrix in row-major order in memory.

Transforms can be parametrized over the source and destination units, to describe a transformation from a space to another. For example, TypedTransform3D<f32, WorldSpace, ScreenSpace>::transform_point3d takes a TypedPoint3D<f32, WorldSpace> and returns a TypedPoint3D<f32, ScreenSpace>.

Transforms expose a set of convenience methods for pre- and post-transformations. A pre-transformation corresponds to adding an operation that is applied before the rest of the transformation, while a post-transformation adds an operation that is applied after.

These transforms are for working with row vectors, so the matrix math for transforming a vector is v * T. If your library is using column vectors, use row_major functions when you are asked for column_major representations and vice versa.

Fields

m11: Tm12: Tm13: Tm14: Tm21: Tm22: Tm23: Tm24: Tm31: Tm32: Tm33: Tm34: Tm41: Tm42: Tm43: Tm44: T

Methods

`impl<T, Src, Dst> TypedTransform3D<T, Src, Dst>`[src]

`pub fn row_major( m11: T, m12: T, m13: T, m14: T, m21: T, m22: T, m23: T, m24: T, m31: T, m32: T, m33: T, m34: T, m41: T, m42: T, m43: T, m44: T ) -> Self`[src]

Create a transform specifying its components in row-major order.

For example, the translation terms m41, m42, m43 on the last row with the row-major convention) are the 13rd, 14th and 15th parameters.

Beware: This library is written with the assumption that row vectors are being used. If your matrices use column vectors (i.e. transforming a vector is T * v), then please use column_major

`pub fn column_major( m11: T, m21: T, m31: T, m41: T, m12: T, m22: T, m32: T, m42: T, m13: T, m23: T, m33: T, m43: T, m14: T, m24: T, m34: T, m44: T ) -> Self`[src]

Create a transform specifying its components in column-major order.

For example, the translation terms m41, m42, m43 on the last column with the column-major convention) are the 4th, 8th and 12nd parameters.

Beware: This library is written with the assumption that row vectors are being used. If your matrices use column vectors (i.e. transforming a vector is T * v), then please use row_major

`impl<T, Src, Dst> TypedTransform3D<T, Src, Dst> where T: Copy + Clone + PartialEq + One + Zero,` [src]

`pub fn identity() -> Self`[src]

`impl<T, Src, Dst> TypedTransform3D<T, Src, Dst> where T: Copy + Clone + Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Neg<Output = T> + PartialOrd + Trig + One + Zero,` [src]

`pub fn row_major_2d(m11: T, m12: T, m21: T, m22: T, m41: T, m42: T) -> Self`[src]

Create a 4 by 4 transform representing a 2d transformation, specifying its components in row-major order.

`pub fn ortho(left: T, right: T, bottom: T, top: T, near: T, far: T) -> Self`[src]

Create an orthogonal projection transform.

`pub fn is_2d(&self) -> bool`[src]

Returns true if this transform can be represented with a TypedTransform2D.

See https://drafts.csswg.org/css-transforms/#2d-transform

`pub fn to_2d(&self) -> TypedTransform2D<T, Src, Dst>`[src]

Create a 2D transform picking the relevant terms from this transform.

This method assumes that self represents a 2d transformation, callers should check that self.is_2d() returns true beforehand.

`pub fn is_backface_visible(&self) -> bool`[src]

Check whether shapes on the XY plane with Z pointing towards the screen transformed by this matrix would be facing back.

`pub fn approx_eq(&self, other: &Self) -> bool where T: ApproxEq<T>,` [src]

`pub fn with_destination<NewDst>(&self) -> TypedTransform3D<T, Src, NewDst>`[src]

Returns the same transform with a different destination unit.

`pub fn with_source<NewSrc>(&self) -> TypedTransform3D<T, NewSrc, Dst>`[src]

Returns the same transform with a different source unit.

`pub fn to_untyped(&self) -> Transform3D<T>`[src]

Drop the units, preserving only the numeric value.

`pub fn from_untyped(m: &Transform3D<T>) -> Self`[src]

Tag a unitless value with units.

`pub fn post_mul<NewDst>( &self, mat: &TypedTransform3D<T, Dst, NewDst> ) -> TypedTransform3D<T, Src, NewDst>`[src]

Returns the multiplication of the two matrices such that mat's transformation applies after self's transformation.

Assuming row vectors, this is equivalent to self * mat

`pub fn pre_mul<NewSrc>( &self, mat: &TypedTransform3D<T, NewSrc, Src> ) -> TypedTransform3D<T, NewSrc, Dst>`[src]

Returns the multiplication of the two matrices such that mat's transformation applies before self's transformation.

Assuming row vectors, this is equivalent to mat * self

`pub fn inverse(&self) -> Option<TypedTransform3D<T, Dst, Src>>`[src]

Returns the inverse transform if possible.

`pub fn determinant(&self) -> T`[src]

Compute the determinant of the transform.

`pub fn mul_s(&self, x: T) -> Self`[src]

Multiplies all of the transform's component by a scalar and returns the result.