Struct euclid::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.
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
sourceimpl<T, Src, Dst> TypedTransform3D<T, Src, Dst>
impl<T, Src, Dst> TypedTransform3D<T, Src, Dst>
sourcepub 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
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
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.
sourcepub 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
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
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.
sourceimpl<T, Src, Dst> TypedTransform3D<T, Src, Dst>where
T: Copy + Clone + PartialEq + One + Zero,
impl<T, Src, Dst> TypedTransform3D<T, Src, Dst>where
T: Copy + Clone + PartialEq + One + Zero,
sourceimpl<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,
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,
sourcepub fn row_major_2d(m11: T, m12: T, m21: T, m22: T, m41: T, m42: T) -> Self
pub fn row_major_2d(m11: T, m12: T, m21: T, m22: T, m41: T, m42: T) -> Self
Create a 4 by 4 transform representing a 2d transformation, specifying its components in row-major order.
sourcepub fn ortho(left: T, right: T, bottom: T, top: T, near: T, far: T) -> Self
pub fn ortho(left: T, right: T, bottom: T, top: T, near: T, far: T) -> Self
Create an orthogonal projection transform.
sourcepub fn is_2d(&self) -> bool
pub fn is_2d(&self) -> bool
Returns true if this transform can be represented with a TypedTransform2D
.
sourcepub fn to_2d(&self) -> TypedTransform2D<T, Src, Dst>
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.
sourcepub fn is_backface_visible(&self) -> bool
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.
pub fn approx_eq(&self, other: &Self) -> boolwhere
T: ApproxEq<T>,
sourcepub fn with_destination<NewDst>(&self) -> TypedTransform3D<T, Src, NewDst>
pub fn with_destination<NewDst>(&self) -> TypedTransform3D<T, Src, NewDst>
Returns the same transform with a different destination unit.
sourcepub fn with_source<NewSrc>(&self) -> TypedTransform3D<T, NewSrc, Dst>
pub fn with_source<NewSrc>(&self) -> TypedTransform3D<T, NewSrc, Dst>
Returns the same transform with a different source unit.
sourcepub fn to_untyped(&self) -> Transform3D<T>
pub fn to_untyped(&self) -> Transform3D<T>
Drop the units, preserving only the numeric value.
sourcepub fn from_untyped(m: &Transform3D<T>) -> Self
pub fn from_untyped(m: &Transform3D<T>) -> Self
Tag a unitless value with units.
sourcepub fn post_mul<NewDst>(
&self,
mat: &TypedTransform3D<T, Dst, NewDst>
) -> TypedTransform3D<T, Src, NewDst>
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.
sourcepub fn pre_mul<NewSrc>(
&self,
mat: &TypedTransform3D<T, NewSrc, Src>
) -> TypedTransform3D<T, NewSrc, Dst>
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.
sourcepub fn inverse(&self) -> Option<TypedTransform3D<T, Dst, Src>>
pub fn inverse(&self) -> Option<TypedTransform3D<T, Dst, Src>>
Returns the inverse transform if possible.
sourcepub fn determinant(&self) -> T
pub fn determinant(&self) -> T
Compute the determinant of the transform.
sourcepub fn mul_s(&self, x: T) -> Self
pub fn mul_s(&self, x: T) -> Self
Multiplies all of the transform’s component by a scalar and returns the result.
sourcepub fn from_scale(scale: TypedScale<T, Src, Dst>) -> Self
pub fn from_scale(scale: TypedScale<T, Src, Dst>) -> Self
Convenience function to create a scale transform from a TypedScale
.
sourcepub fn transform_point2d_homogeneous(
&self,
p: &TypedPoint2D<T, Src>
) -> HomogeneousVector<T, Dst>
pub fn transform_point2d_homogeneous(
&self,
p: &TypedPoint2D<T, Src>
) -> HomogeneousVector<T, Dst>
Returns the homogeneous vector corresponding to the transformed 2d point.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_point2d(
&self,
p: &TypedPoint2D<T, Src>
) -> Option<TypedPoint2D<T, Dst>>
pub fn transform_point2d(
&self,
p: &TypedPoint2D<T, Src>
) -> Option<TypedPoint2D<T, Dst>>
Returns the given 2d point transformed by this transform, if the transform makes sense,
or None
otherwise.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_vector2d(
&self,
v: &TypedVector2D<T, Src>
) -> TypedVector2D<T, Dst>
pub fn transform_vector2d(
&self,
v: &TypedVector2D<T, Src>
) -> TypedVector2D<T, Dst>
Returns the given 2d vector transformed by this matrix.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_point3d_homogeneous(
&self,
p: &TypedPoint3D<T, Src>
) -> HomogeneousVector<T, Dst>
pub fn transform_point3d_homogeneous(
&self,
p: &TypedPoint3D<T, Src>
) -> HomogeneousVector<T, Dst>
Returns the homogeneous vector corresponding to the transformed 3d point.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_point3d(
&self,
p: &TypedPoint3D<T, Src>
) -> Option<TypedPoint3D<T, Dst>>
pub fn transform_point3d(
&self,
p: &TypedPoint3D<T, Src>
) -> Option<TypedPoint3D<T, Dst>>
Returns the given 3d point transformed by this transform, if the transform makes sense,
or None
otherwise.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_vector3d(
&self,
v: &TypedVector3D<T, Src>
) -> TypedVector3D<T, Dst>
pub fn transform_vector3d(
&self,
v: &TypedVector3D<T, Src>
) -> TypedVector3D<T, Dst>
Returns the given 3d vector transformed by this matrix.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_rect(
&self,
rect: &TypedRect<T, Src>
) -> Option<TypedRect<T, Dst>>
pub fn transform_rect(
&self,
rect: &TypedRect<T, Src>
) -> Option<TypedRect<T, Dst>>
Returns a rectangle that encompasses the result of transforming the given rectangle by this
transform, if the transform makes sense for it, or None
otherwise.
sourcepub fn create_translation(x: T, y: T, z: T) -> Self
pub fn create_translation(x: T, y: T, z: T) -> Self
Create a 3d translation transform
sourcepub fn pre_translate(&self, v: TypedVector3D<T, Src>) -> Self
pub fn pre_translate(&self, v: TypedVector3D<T, Src>) -> Self
Returns a transform with a translation applied before self’s transformation.
sourcepub fn post_translate(&self, v: TypedVector3D<T, Dst>) -> Self
pub fn post_translate(&self, v: TypedVector3D<T, Dst>) -> Self
Returns a transform with a translation applied after self’s transformation.
sourcepub fn project_to_2d(&self) -> Self
pub fn project_to_2d(&self) -> Self
Returns a projection of this transform in 2d space.
sourcepub fn create_scale(x: T, y: T, z: T) -> Self
pub fn create_scale(x: T, y: T, z: T) -> Self
Create a 3d scale transform
sourcepub fn pre_scale(&self, x: T, y: T, z: T) -> Self
pub fn pre_scale(&self, x: T, y: T, z: T) -> Self
Returns a transform with a scale applied before self’s transformation.
sourcepub fn post_scale(&self, x: T, y: T, z: T) -> Self
pub fn post_scale(&self, x: T, y: T, z: T) -> Self
Returns a transform with a scale applied after self’s transformation.
sourcepub fn create_rotation(x: T, y: T, z: T, theta: Angle<T>) -> Self
pub fn create_rotation(x: T, y: T, z: T, theta: Angle<T>) -> Self
Create a 3d rotation transform from an angle / axis. The supplied axis must be normalized.
sourcepub fn post_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self
pub fn post_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self
Returns a transform with a rotation applied after self’s transformation.
sourcepub fn pre_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self
pub fn pre_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self
Returns a transform with a rotation applied before self’s transformation.
sourcepub fn create_skew(alpha: Angle<T>, beta: Angle<T>) -> Self
pub fn create_skew(alpha: Angle<T>, beta: Angle<T>) -> Self
Create a 2d skew transform.
sourcepub fn create_perspective(d: T) -> Self
pub fn create_perspective(d: T) -> Self
Create a simple perspective projection transform
sourceimpl<T: Copy, Src, Dst> TypedTransform3D<T, Src, Dst>
impl<T: Copy, Src, Dst> TypedTransform3D<T, Src, Dst>
sourcepub fn to_row_major_array(&self) -> [T; 16]
pub fn to_row_major_array(&self) -> [T; 16]
Returns an array containing this transform’s terms in row-major order (the order in which the transform is actually laid out in memory).
sourcepub fn to_column_major_array(&self) -> [T; 16]
pub fn to_column_major_array(&self) -> [T; 16]
Returns an array containing this transform’s terms in column-major order.
sourcepub fn to_row_arrays(&self) -> [[T; 4]; 4]
pub fn to_row_arrays(&self) -> [[T; 4]; 4]
Returns an array containing this transform’s 4 rows in (in row-major order) as arrays.
This is a convenience method to interface with other libraries like glium.
sourcepub fn to_column_arrays(&self) -> [[T; 4]; 4]
pub fn to_column_arrays(&self) -> [[T; 4]; 4]
Returns an array containing this transform’s 4 columns in (in row-major order, or 4 rows in column-major order) as arrays.
This is a convenience method to interface with other libraries like glium.
sourcepub fn from_array(array: [T; 16]) -> Self
pub fn from_array(array: [T; 16]) -> Self
Creates a transform from an array of 16 elements in row-major order.
sourcepub fn from_row_arrays(array: [[T; 4]; 4]) -> Self
pub fn from_row_arrays(array: [[T; 4]; 4]) -> Self
Creates a transform from 4 rows of 4 elements (row-major order).
sourceimpl<T0: NumCast + Copy, Src, Dst> TypedTransform3D<T0, Src, Dst>
impl<T0: NumCast + Copy, Src, Dst> TypedTransform3D<T0, Src, Dst>
sourcepub fn cast<T1: NumCast + Copy>(&self) -> TypedTransform3D<T1, Src, Dst>
pub fn cast<T1: NumCast + Copy>(&self) -> TypedTransform3D<T1, Src, Dst>
Cast from one numeric representation to another, preserving the units.