[−][src]Struct euclid::Transform3D
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, Transform3D<f32, WorldSpace, ScreenSpace>::transform_point3d
takes a Point3D<f32, WorldSpace>
and returns a Point3D<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
impl<T, Src, Dst> Transform3D<T, Src, Dst>
[src]
pub const 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]
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.
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 row_major_2d(m11: T, m12: T, m21: T, m22: T, m41: T, m42: T) -> Self where
T: Zero + One,
[src]
T: Zero + One,
Create a 4 by 4 transform representing a 2d transformation, specifying its components in row-major order:
m11 m12 0 0
m21 m22 0 0
0 0 1 0
m41 m42 0 1
pub const 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]
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.
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
pub fn is_2d(&self) -> bool where
T: Zero + One + PartialEq,
[src]
T: Zero + One + PartialEq,
Returns true
if this transform can be represented with a Transform2D
.
impl<T: Copy, Src, Dst> Transform3D<T, Src, Dst>
[src]
pub fn to_row_major_array(&self) -> [T; 16]
[src]
Returns an array containing this transform's terms in row-major order (the order in which the transform is actually laid out in memory).
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 to_column_major_array
pub fn to_column_major_array(&self) -> [T; 16]
[src]
Returns an array containing this transform's terms in column-major order.
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 to_row_major_array
pub fn to_row_arrays(&self) -> [[T; 4]; 4]
[src]
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.
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 to_column_arrays
pub fn to_column_arrays(&self) -> [[T; 4]; 4]
[src]
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.
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 to_row_arrays
pub fn from_array(array: [T; 16]) -> Self
[src]
Creates a transform from an array of 16 elements in row-major order.
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
), please provide column-major data to this function.
pub fn from_row_arrays(array: [[T; 4]; 4]) -> Self
[src]
Creates a transform from 4 rows of 4 elements (row-major order).
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
), please provide column-major data to tis function.
pub fn from_untyped(m: &Transform3D<T, UnknownUnit, UnknownUnit>) -> Self
[src]
Tag a unitless value with units.
pub fn to_untyped(&self) -> Transform3D<T, UnknownUnit, UnknownUnit>
[src]
Drop the units, preserving only the numeric value.
pub fn with_source<NewSrc>(&self) -> Transform3D<T, NewSrc, Dst>
[src]
Returns the same transform with a different source unit.
pub fn with_destination<NewDst>(&self) -> Transform3D<T, Src, NewDst>
[src]
Returns the same transform with a different destination unit.
pub fn to_2d(&self) -> Transform2D<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.
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Zero + One,
[src]
T: Zero + One,
pub fn identity() -> Self
[src]
Creates an identity matrix:
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
pub fn create_skew(alpha: Angle<T>, beta: Angle<T>) -> Self where
T: Trig,
[src]
T: Trig,
Create a 2d skew transform.
pub fn create_perspective(d: T) -> Self where
T: Neg<Output = T> + Div<Output = T>,
[src]
T: Neg<Output = T> + Div<Output = T>,
Create a simple perspective projection transform:
1 0 0 0
0 1 0 0
0 0 1 -1/d
0 0 0 1
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Copy + Add<Output = T> + Mul<Output = T>,
[src]
T: Copy + Add<Output = T> + Mul<Output = T>,
Methods for combining generic transformations
#[must_use]pub fn post_transform<NewDst>(
&self,
mat: &Transform3D<T, Dst, NewDst>
) -> Transform3D<T, Src, NewDst>
[src]
&self,
mat: &Transform3D<T, Dst, NewDst>
) -> Transform3D<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
#[must_use]pub fn pre_transform<NewSrc>(
&self,
mat: &Transform3D<T, NewSrc, Src>
) -> Transform3D<T, NewSrc, Dst>
[src]
&self,
mat: &Transform3D<T, NewSrc, Src>
) -> Transform3D<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
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Zero + One,
[src]
T: Zero + One,
Methods for creating and combining translation transformations
pub fn create_translation(x: T, y: T, z: T) -> Self
[src]
Create a 3d translation transform:
1 0 0 0
0 1 0 0
0 0 1 0
x y z 1
#[must_use]pub fn pre_translate(&self, v: Vector3D<T, Src>) -> Self where
T: Copy + Add<Output = T> + Mul<Output = T>,
[src]
T: Copy + Add<Output = T> + Mul<Output = T>,
Returns a transform with a translation applied before self's transformation.
#[must_use]pub fn post_translate(&self, v: Vector3D<T, Dst>) -> Self where
T: Copy + Add<Output = T> + Mul<Output = T>,
[src]
T: Copy + Add<Output = T> + Mul<Output = T>,
Returns a transform with a translation applied after self's transformation.
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + Zero + One + Trig,
[src]
T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + Zero + One + Trig,
Methods for creating and combining rotation transformations
pub fn create_rotation(x: T, y: T, z: T, theta: Angle<T>) -> Self
[src]
Create a 3d rotation transform from an angle / axis. The supplied axis must be normalized.
#[must_use]pub fn post_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self
[src]
Returns a transform with a rotation applied after self's transformation.
#[must_use]pub fn pre_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self
[src]
Returns a transform with a rotation applied before self's transformation.
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Zero + One,
[src]
T: Zero + One,
Methods for creating and combining scale transformations
pub fn create_scale(x: T, y: T, z: T) -> Self
[src]
Create a 3d scale transform:
x 0 0 0
0 y 0 0
0 0 z 0
0 0 0 1
#[must_use]pub fn pre_scale(&self, x: T, y: T, z: T) -> Self where
T: Copy + Add<Output = T> + Mul<Output = T>,
[src]
T: Copy + Add<Output = T> + Mul<Output = T>,
Returns a transform with a scale applied before self's transformation.
#[must_use]pub fn post_scale(&self, x: T, y: T, z: T) -> Self where
T: Copy + Add<Output = T> + Mul<Output = T>,
[src]
T: Copy + Add<Output = T> + Mul<Output = T>,
Returns a transform with a scale applied after self's transformation.
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Copy + Add<Output = T> + Mul<Output = T>,
[src]
T: Copy + Add<Output = T> + Mul<Output = T>,
Methods for apply transformations to objects
pub fn transform_point2d_homogeneous(
&self,
p: Point2D<T, Src>
) -> HomogeneousVector<T, Dst>
[src]
&self,
p: Point2D<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.
Assuming row vectors, this is equivalent to p * self
pub fn transform_point2d(&self, p: Point2D<T, Src>) -> Option<Point2D<T, Dst>> where
T: Div<Output = T> + Zero + PartialOrd,
[src]
T: Div<Output = T> + Zero + PartialOrd,
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.
Assuming row vectors, this is equivalent to p * self
pub fn transform_vector2d(&self, v: Vector2D<T, Src>) -> Vector2D<T, Dst>
[src]
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.
Assuming row vectors, this is equivalent to v * self
pub fn transform_point3d_homogeneous(
&self,
p: Point3D<T, Src>
) -> HomogeneousVector<T, Dst>
[src]
&self,
p: Point3D<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.
Assuming row vectors, this is equivalent to p * self
pub fn transform_point3d(&self, p: Point3D<T, Src>) -> Option<Point3D<T, Dst>> where
T: Div<Output = T> + Zero + PartialOrd,
[src]
T: Div<Output = T> + Zero + PartialOrd,
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.
Assuming row vectors, this is equivalent to p * self
pub fn transform_vector3d(&self, v: Vector3D<T, Src>) -> Vector3D<T, Dst>
[src]
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.
Assuming row vectors, this is equivalent to v * self
pub fn transform_rect(&self, rect: &Rect<T, Src>) -> Option<Rect<T, Dst>> where
T: Sub<Output = T> + Div<Output = T> + Zero + PartialOrd,
[src]
T: Sub<Output = T> + Div<Output = T> + Zero + PartialOrd,
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.
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Copy + Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Neg<Output = T> + PartialOrd + One + Zero,
[src]
T: Copy + Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Neg<Output = T> + PartialOrd + One + Zero,
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_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 is_invertible(&self) -> bool
[src]
Returns whether it is possible to compute the inverse transform.
pub fn inverse(&self) -> Option<Transform3D<T, Dst, Src>>
[src]
Returns the inverse transform if possible.
pub fn determinant(&self) -> T
[src]
Compute the determinant of the transform.
#[must_use]pub fn mul_s(&self, x: T) -> Self
[src]
Multiplies all of the transform's component by a scalar and returns the result.
pub fn from_scale(scale: Scale<T, Src, Dst>) -> Self
[src]
Convenience function to create a scale transform from a Scale
.
impl<T, Src, Dst> Transform3D<T, Src, Dst> where
T: Copy + Mul<Output = T> + Div<Output = T> + Zero + One + PartialEq,
[src]
T: Copy + Mul<Output = T> + Div<Output = T> + Zero + One + PartialEq,
pub fn project_to_2d(&self) -> Self
[src]
Returns a projection of this transform in 2d space.
impl<T: NumCast + Copy, Src, Dst> Transform3D<T, Src, Dst>
[src]
pub fn cast<NewT: NumCast>(&self) -> Transform3D<NewT, Src, Dst>
[src]
Cast from one numeric representation to another, preserving the units.
pub fn try_cast<NewT: NumCast>(&self) -> Option<Transform3D<NewT, Src, Dst>>
[src]
Fallible cast from one numeric representation to another, preserving the units.
impl<T: ApproxEq<T>, Src, Dst> Transform3D<T, Src, Dst>
[src]
pub fn approx_eq(&self, other: &Self) -> bool
[src]
Returns true is this transform is approximately equal to the other one, using T's default epsilon value.
The same as ApproxEq::approx_eq()
but available without importing trait.
pub fn approx_eq_eps(&self, other: &Self, eps: &T) -> bool
[src]
Returns true is this transform is approximately equal to the other one, using a provided epsilon value.
The same as ApproxEq::approx_eq_eps()
but available without importing trait.
Trait Implementations
impl<T: ApproxEq<T>, Src, Dst> ApproxEq<T> for Transform3D<T, Src, Dst>
[src]
fn approx_epsilon() -> T
[src]
fn approx_eq_eps(&self, other: &Self, eps: &T) -> bool
[src]
fn approx_eq(&self, other: &Self) -> bool
[src]
impl<T: Clone, Src, Dst> Clone for Transform3D<T, Src, Dst>
[src]
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: Copy, Src, Dst> Copy for Transform3D<T, Src, Dst>
[src]
impl<T, Src, Dst> Debug for Transform3D<T, Src, Dst> where
T: Copy + Debug + PartialEq + One + Zero,
[src]
T: Copy + Debug + PartialEq + One + Zero,
impl<T, Src, Dst> Default for Transform3D<T, Src, Dst> where
T: Zero + One,
[src]
T: Zero + One,
fn default() -> Self
[src]
Returns the identity transform.
impl<T, Src, Dst> Eq for Transform3D<T, Src, Dst> where
T: Eq,
[src]
T: Eq,
impl<T, Src, Dst> Hash for Transform3D<T, Src, Dst> where
T: Hash,
[src]
T: Hash,
fn hash<H: Hasher>(&self, h: &mut H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T, Src, Dst> Into<Transform3D<T, Src, Dst>> for Translation3D<T, Src, Dst> where
T: Zero + One,
[src]
T: Zero + One,
fn into(self) -> Transform3D<T, Src, Dst>
[src]
impl<T, Src, Dst> PartialEq<Transform3D<T, Src, Dst>> for Transform3D<T, Src, Dst> where
T: PartialEq,
[src]
T: PartialEq,
Auto Trait Implementations
impl<T, Src, Dst> RefUnwindSafe for Transform3D<T, Src, Dst> where
Dst: RefUnwindSafe,
Src: RefUnwindSafe,
T: RefUnwindSafe,
Dst: RefUnwindSafe,
Src: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, Src, Dst> Send for Transform3D<T, Src, Dst> where
Dst: Send,
Src: Send,
T: Send,
Dst: Send,
Src: Send,
T: Send,
impl<T, Src, Dst> Sync for Transform3D<T, Src, Dst> where
Dst: Sync,
Src: Sync,
T: Sync,
Dst: Sync,
Src: Sync,
T: Sync,
impl<T, Src, Dst> Unpin for Transform3D<T, Src, Dst> where
Dst: Unpin,
Src: Unpin,
T: Unpin,
Dst: Unpin,
Src: Unpin,
T: Unpin,
impl<T, Src, Dst> UnwindSafe for Transform3D<T, Src, Dst> where
Dst: UnwindSafe,
Src: UnwindSafe,
T: UnwindSafe,
Dst: UnwindSafe,
Src: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,