Struct TypedTransform3D

Source

#[repr(C)]
pub struct TypedTransform3D<T, Src, Dst> {Show 16 fields
    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,
    /* private fields */
}

Expand description

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: 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

Implementations§

Source §

impl<T, Src, Dst> TypedTransform3D<T, Src, Dst>

Source

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, ) -> TypedTransform3D<T, Src, Dst>

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

Source

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, ) -> TypedTransform3D<T, Src, Dst>

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

Source §

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

Source

pub fn identity() -> TypedTransform3D<T, Src, Dst>

Source §

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

Source

pub fn row_major_2d( m11: T, m12: T, m21: T, m22: T, m41: T, m42: T, ) -> TypedTransform3D<T, Src, Dst>

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

Source

pub fn ortho( left: T, right: T, bottom: T, top: T, near: T, far: T, ) -> TypedTransform3D<T, Src, Dst>

Create an orthogonal projection transform.

Source

pub fn is_2d(&self) -> bool

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

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

Source

pub fn to_2d(&self) -> TypedTransform2D<T, Src, Dst>

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.

Source

pub fn is_backface_visible(&self) -> bool

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

Source

pub fn approx_eq(&self, other: &TypedTransform3D<T, Src, Dst>) -> bool
where T: ApproxEq<T>,

Source

pub fn with_destination<NewDst>(&self) -> TypedTransform3D<T, Src, NewDst>

Returns the same transform with a different destination unit.

Source

pub fn with_source<NewSrc>(&self) -> TypedTransform3D<T, NewSrc, Dst>

Returns the same transform with a different source unit.

Source

pub fn to_untyped(&self) -> TypedTransform3D<T, UnknownUnit, UnknownUnit>

Drop the units, preserving only the numeric value.

Source

pub fn from_untyped( m: &TypedTransform3D<T, UnknownUnit, UnknownUnit>, ) -> TypedTransform3D<T, Src, Dst>

Tag a unitless value with units.

Source

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

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

Source

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

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

Source

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

Returns the inverse transform if possible.

Source

pub fn determinant(&self) -> T

Compute the determinant of the transform.

Source

pub fn mul_s(&self, x: T) -> TypedTransform3D<T, Src, Dst>

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

Source

pub fn from_scale( scale: TypedScale<T, Src, Dst>, ) -> TypedTransform3D<T, Src, Dst>

Convenience function to create a scale transform from a TypedScale.

Source