diff options
Diffstat (limited to 'third_party/rust/euclid/src/transform3d.rs')
| -rw-r--r-- | third_party/rust/euclid/src/transform3d.rs | 1436 |
1 files changed, 1436 insertions, 0 deletions
diff --git a/third_party/rust/euclid/src/transform3d.rs b/third_party/rust/euclid/src/transform3d.rs new file mode 100644 index 0000000000..2ea4730ad2 --- /dev/null +++ b/third_party/rust/euclid/src/transform3d.rs @@ -0,0 +1,1436 @@ +// Copyright 2013 The Servo Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![cfg_attr(feature = "cargo-clippy", allow(just_underscores_and_digits))] + +use super::{UnknownUnit, Angle}; +use crate::approxeq::ApproxEq; +use crate::homogen::HomogeneousVector; +#[cfg(feature = "mint")] +use mint; +use crate::trig::Trig; +use crate::point::{Point2D, point2, Point3D, point3}; +use crate::vector::{Vector2D, Vector3D, vec2, vec3}; +use crate::rect::Rect; +use crate::box2d::Box2D; +use crate::box3d::Box3D; +use crate::transform2d::Transform2D; +use crate::scale::Scale; +use crate::num::{One, Zero}; +use core::ops::{Add, Mul, Sub, Div, Neg}; +use core::marker::PhantomData; +use core::fmt; +use core::cmp::{Eq, PartialEq}; +use core::hash::{Hash}; +use num_traits::NumCast; +#[cfg(feature = "serde")] +use serde::{Deserialize, Serialize}; +#[cfg(feature = "bytemuck")] +use bytemuck::{Zeroable, Pod}; + +/// A 3d transform stored as a column-major 4 by 4 matrix. +/// +/// 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. +/// Pre-transformations (`pre_*` methods) correspond to adding an operation that is +/// applied before the rest of the transformation, while post-transformations (`then_*` +/// methods) add an operation that is applied after. +/// +/// When translating Transform3D into general matrix representations, consider that the +/// representation follows the column major notation with column vectors. +/// +/// ```text +/// |x'| | m11 m12 m13 m14 | |x| +/// |y'| | m21 m22 m23 m24 | |y| +/// |z'| = | m31 m32 m33 m34 | x |y| +/// |w | | m41 m42 m43 m44 | |1| +/// ``` +/// +/// The translation terms are m41, m42 and m43. +#[repr(C)] +#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr( + feature = "serde", + serde(bound(serialize = "T: Serialize", deserialize = "T: Deserialize<'de>")) +)] +pub struct Transform3D<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, + #[doc(hidden)] + pub _unit: PhantomData<(Src, Dst)>, +} + + +#[cfg(feature = "arbitrary")] +impl<'a, T, Src, Dst> arbitrary::Arbitrary<'a> for Transform3D<T, Src, Dst> +where + T: arbitrary::Arbitrary<'a>, +{ + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> + { + let (m11, m12, m13, m14) = arbitrary::Arbitrary::arbitrary(u)?; + let (m21, m22, m23, m24) = arbitrary::Arbitrary::arbitrary(u)?; + let (m31, m32, m33, m34) = arbitrary::Arbitrary::arbitrary(u)?; + let (m41, m42, m43, m44) = arbitrary::Arbitrary::arbitrary(u)?; + + Ok(Transform3D { + m11, + m12, + m13, + m14, + m21, + m22, + m23, + m24, + m31, + m32, + m33, + m34, + m41, + m42, + m43, + m44, + _unit: PhantomData, + }) + } +} + +#[cfg(feature = "bytemuck")] +unsafe impl<T: Zeroable, Src, Dst> Zeroable for Transform3D<T, Src, Dst> {} + +#[cfg(feature = "bytemuck")] +unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for Transform3D<T, Src, Dst> {} + +impl<T: Copy, Src, Dst> Copy for Transform3D<T, Src, Dst> {} + +impl<T: Clone, Src, Dst> Clone for Transform3D<T, Src, Dst> { + fn clone(&self) -> Self { + Transform3D { + m11: self.m11.clone(), + m12: self.m12.clone(), + m13: self.m13.clone(), + m14: self.m14.clone(), + m21: self.m21.clone(), + m22: self.m22.clone(), + m23: self.m23.clone(), + m24: self.m24.clone(), + m31: self.m31.clone(), + m32: self.m32.clone(), + m33: self.m33.clone(), + m34: self.m34.clone(), + m41: self.m41.clone(), + m42: self.m42.clone(), + m43: self.m43.clone(), + m44: self.m44.clone(), + _unit: PhantomData, + } + } +} + +impl<T, Src, Dst> Eq for Transform3D<T, Src, Dst> where T: Eq {} + +impl<T, Src, Dst> PartialEq for Transform3D<T, Src, Dst> + where T: PartialEq +{ + fn eq(&self, other: &Self) -> bool { + self.m11 == other.m11 && + self.m12 == other.m12 && + self.m13 == other.m13 && + self.m14 == other.m14 && + self.m21 == other.m21 && + self.m22 == other.m22 && + self.m23 == other.m23 && + self.m24 == other.m24 && + self.m31 == other.m31 && + self.m32 == other.m32 && + self.m33 == other.m33 && + self.m34 == other.m34 && + self.m41 == other.m41 && + self.m42 == other.m42 && + self.m43 == other.m43 && + self.m44 == other.m44 + } +} + +impl<T, Src, Dst> Hash for Transform3D<T, Src, Dst> + where T: Hash +{ + fn hash<H: core::hash::Hasher>(&self, h: &mut H) { + self.m11.hash(h); + self.m12.hash(h); + self.m13.hash(h); + self.m14.hash(h); + self.m21.hash(h); + self.m22.hash(h); + self.m23.hash(h); + self.m24.hash(h); + self.m31.hash(h); + self.m32.hash(h); + self.m33.hash(h); + self.m34.hash(h); + self.m41.hash(h); + self.m42.hash(h); + self.m43.hash(h); + self.m44.hash(h); + } +} + + +impl<T, Src, Dst> Transform3D<T, Src, Dst> { + /// Create a transform specifying all of it's component as a 4 by 4 matrix. + /// + /// Components are specified following column-major-column-vector matrix notation. + /// For example, the translation terms m41, m42, m43 are the 13rd, 14th and 15th parameters. + /// + /// ``` + /// use euclid::default::Transform3D; + /// let tx = 1.0; + /// let ty = 2.0; + /// let tz = 3.0; + /// let translation = Transform3D::new( + /// 1.0, 0.0, 0.0, 0.0, + /// 0.0, 1.0, 0.0, 0.0, + /// 0.0, 0.0, 1.0, 0.0, + /// tx, ty, tz, 1.0, + /// ); + /// ``` + #[inline] + #[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))] + pub const fn new( + 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 { + Transform3D { + m11, m12, m13, m14, + m21, m22, m23, m24, + m31, m32, m33, m34, + m41, m42, m43, m44, + _unit: PhantomData, + } + } + + /// Create a transform representing a 2d transformation from the components + /// of a 2 by 3 matrix transformation. + /// + /// Components follow the column-major-column-vector notation (m41 and m42 + /// representating the translation terms). + /// + /// ```text + /// m11 m12 0 0 + /// m21 m22 0 0 + /// 0 0 1 0 + /// m41 m42 0 1 + /// ``` + #[inline] + pub fn new_2d(m11: T, m12: T, m21: T, m22: T, m41: T, m42: T) -> Self + where + T: Zero + One, + { + let _0 = || T::zero(); + let _1 = || T::one(); + + Self::new( + m11, m12, _0(), _0(), + m21, m22, _0(), _0(), + _0(), _0(), _1(), _0(), + m41, m42, _0(), _1() + ) + } + + + /// Returns `true` if this transform can be represented with a `Transform2D`. + /// + /// See <https://drafts.csswg.org/css-transforms/#2d-transform> + #[inline] + pub fn is_2d(&self) -> bool + where + T: Zero + One + PartialEq, + { + let (_0, _1): (T, T) = (Zero::zero(), One::one()); + self.m31 == _0 && self.m32 == _0 && + self.m13 == _0 && self.m23 == _0 && + self.m43 == _0 && self.m14 == _0 && + self.m24 == _0 && self.m34 == _0 && + self.m33 == _1 && self.m44 == _1 + } +} + +impl<T: Copy, Src, Dst> Transform3D<T, Src, Dst> { + /// Returns an array containing this transform's terms. + /// + /// The terms are laid out in the same order as they are + /// specified in `Transform3D::new`, that is following the + /// column-major-column-vector matrix notation. + /// + /// For example the translation terms are found on the + /// 13th, 14th and 15th slots of the array. + #[inline] + pub fn to_array(&self) -> [T; 16] { + [ + self.m11, self.m12, self.m13, self.m14, + self.m21, self.m22, self.m23, self.m24, + self.m31, self.m32, self.m33, self.m34, + self.m41, self.m42, self.m43, self.m44 + ] + } + + /// Returns an array containing this transform's terms transposed. + /// + /// The terms are laid out in transposed order from the same order of + /// `Transform3D::new` and `Transform3D::to_array`, that is following + /// the row-major-column-vector matrix notation. + /// + /// For example the translation terms are found at indices 3, 7 and 11 + /// of the array. + #[inline] + pub fn to_array_transposed(&self) -> [T; 16] { + [ + self.m11, self.m21, self.m31, self.m41, + self.m12, self.m22, self.m32, self.m42, + self.m13, self.m23, self.m33, self.m43, + self.m14, self.m24, self.m34, self.m44 + ] + } + + /// Equivalent to `to_array` with elements packed four at a time + /// in an array of arrays. + #[inline] + pub fn to_arrays(&self) -> [[T; 4]; 4] { + [ + [self.m11, self.m12, self.m13, self.m14], + [self.m21, self.m22, self.m23, self.m24], + [self.m31, self.m32, self.m33, self.m34], + [self.m41, self.m42, self.m43, self.m44] + ] + } + + /// Equivalent to `to_array_transposed` with elements packed + /// four at a time in an array of arrays. + #[inline] + pub fn to_arrays_transposed(&self) -> [[T; 4]; 4] { + [ + [self.m11, self.m21, self.m31, self.m41], + [self.m12, self.m22, self.m32, self.m42], + [self.m13, self.m23, self.m33, self.m43], + [self.m14, self.m24, self.m34, self.m44] + ] + } + + /// Create a transform providing its components via an array + /// of 16 elements instead of as individual parameters. + /// + /// The order of the components corresponds to the + /// column-major-column-vector matrix notation (the same order + /// as `Transform3D::new`). + #[inline] + pub fn from_array(array: [T; 16]) -> Self { + Self::new( + array[0], array[1], array[2], array[3], + array[4], array[5], array[6], array[7], + array[8], array[9], array[10], array[11], + array[12], array[13], array[14], array[15], + ) + } + + /// Equivalent to `from_array` with elements packed four at a time + /// in an array of arrays. + /// + /// The order of the components corresponds to the + /// column-major-column-vector matrix notation (the same order + /// as `Transform3D::new`). + #[inline] + pub fn from_arrays(array: [[T; 4]; 4]) -> Self { + Self::new( + array[0][0], array[0][1], array[0][2], array[0][3], + array[1][0], array[1][1], array[1][2], array[1][3], + array[2][0], array[2][1], array[2][2], array[2][3], + array[3][0], array[3][1], array[3][2], array[3][3], + ) + } + + /// Tag a unitless value with units. + #[inline] + pub fn from_untyped(m: &Transform3D<T, UnknownUnit, UnknownUnit>) -> Self { + Transform3D::new( + m.m11, m.m12, m.m13, m.m14, + m.m21, m.m22, m.m23, m.m24, + m.m31, m.m32, m.m33, m.m34, + m.m41, m.m42, m.m43, m.m44, + ) + } + + /// Drop the units, preserving only the numeric value. + #[inline] + pub fn to_untyped(&self) -> Transform3D<T, UnknownUnit, UnknownUnit> { + Transform3D::new( + self.m11, self.m12, self.m13, self.m14, + self.m21, self.m22, self.m23, self.m24, + self.m31, self.m32, self.m33, self.m34, + self.m41, self.m42, self.m43, self.m44, + ) + } + + /// Returns the same transform with a different source unit. + #[inline] + pub fn with_source<NewSrc>(&self) -> Transform3D<T, NewSrc, Dst> { + Transform3D::new( + self.m11, self.m12, self.m13, self.m14, + self.m21, self.m22, self.m23, self.m24, + self.m31, self.m32, self.m33, self.m34, + self.m41, self.m42, self.m43, self.m44, + ) + } + + /// Returns the same transform with a different destination unit. + #[inline] + pub fn with_destination<NewDst>(&self) -> Transform3D<T, Src, NewDst> { + Transform3D::new( + self.m11, self.m12, self.m13, self.m14, + self.m21, self.m22, self.m23, self.m24, + self.m31, self.m32, self.m33, self.m34, + self.m41, self.m42, self.m43, self.m44, + ) + } + + /// 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. + /// + /// [`self.is_2d()`]: #method.is_2d + pub fn to_2d(&self) -> Transform2D<T, Src, Dst> { + Transform2D::new( + self.m11, self.m12, + self.m21, self.m22, + self.m41, self.m42 + ) + } +} + +impl <T, Src, Dst> Transform3D<T, Src, Dst> +where + T: Zero + One, +{ + /// Creates an identity matrix: + /// + /// ```text + /// 1 0 0 0 + /// 0 1 0 0 + /// 0 0 1 0 + /// 0 0 0 1 + /// ``` + #[inline] + pub fn identity() -> Self { + Self::translation(T::zero(), T::zero(), T::zero()) + } + + /// Intentional not public, because it checks for exact equivalence + /// while most consumers will probably want some sort of approximate + /// equivalence to deal with floating-point errors. + #[inline] + fn is_identity(&self) -> bool + where + T: PartialEq, + { + *self == Self::identity() + } + + /// Create a 2d skew transform. + /// + /// See <https://drafts.csswg.org/css-transforms/#funcdef-skew> + pub fn skew(alpha: Angle<T>, beta: Angle<T>) -> Self + where + T: Trig, + { + let _0 = || T::zero(); + let _1 = || T::one(); + let (sx, sy) = (beta.radians.tan(), alpha.radians.tan()); + + Self::new( + _1(), sx, _0(), _0(), + sy, _1(), _0(), _0(), + _0(), _0(), _1(), _0(), + _0(), _0(), _0(), _1(), + ) + } + + /// Create a simple perspective transform, projecting to the plane `z = -d`. + /// + /// ```text + /// 1 0 0 0 + /// 0 1 0 0 + /// 0 0 1 -1/d + /// 0 0 0 1 + /// ``` + /// + /// See <https://drafts.csswg.org/css-transforms-2/#PerspectiveDefined>. + pub fn perspective(d: T) -> Self + where + T: Neg<Output = T> + Div<Output = T>, + { + let _0 = || T::zero(); + let _1 = || T::one(); + + Self::new( + _1(), _0(), _0(), _0(), + _0(), _1(), _0(), _0(), + _0(), _0(), _1(), -_1() / d, + _0(), _0(), _0(), _1(), + ) + } +} + + +/// Methods for combining generic transformations +impl <T, Src, Dst> Transform3D<T, Src, Dst> +where + T: Copy + Add<Output = T> + Mul<Output = T>, +{ + /// 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 then<NewDst>(&self, other: &Transform3D<T, Dst, NewDst>) -> Transform3D<T, Src, NewDst> { + Transform3D::new( + self.m11 * other.m11 + self.m12 * other.m21 + self.m13 * other.m31 + self.m14 * other.m41, + self.m11 * other.m12 + self.m12 * other.m22 + self.m13 * other.m32 + self.m14 * other.m42, + self.m11 * other.m13 + self.m12 * other.m23 + self.m13 * other.m33 + self.m14 * other.m43, + self.m11 * other.m14 + self.m12 * other.m24 + self.m13 * other.m34 + self.m14 * other.m44, + + self.m21 * other.m11 + self.m22 * other.m21 + self.m23 * other.m31 + self.m24 * other.m41, + self.m21 * other.m12 + self.m22 * other.m22 + self.m23 * other.m32 + self.m24 * other.m42, + self.m21 * other.m13 + self.m22 * other.m23 + self.m23 * other.m33 + self.m24 * other.m43, + self.m21 * other.m14 + self.m22 * other.m24 + self.m23 * other.m34 + self.m24 * other.m44, + + self.m31 * other.m11 + self.m32 * other.m21 + self.m33 * other.m31 + self.m34 * other.m41, + self.m31 * other.m12 + self.m32 * other.m22 + self.m33 * other.m32 + self.m34 * other.m42, + self.m31 * other.m13 + self.m32 * other.m23 + self.m33 * other.m33 + self.m34 * other.m43, + self.m31 * other.m14 + self.m32 * other.m24 + self.m33 * other.m34 + self.m34 * other.m44, + + self.m41 * other.m11 + self.m42 * other.m21 + self.m43 * other.m31 + self.m44 * other.m41, + self.m41 * other.m12 + self.m42 * other.m22 + self.m43 * other.m32 + self.m44 * other.m42, + self.m41 * other.m13 + self.m42 * other.m23 + self.m43 * other.m33 + self.m44 * other.m43, + self.m41 * other.m14 + self.m42 * other.m24 + self.m43 * other.m34 + self.m44 * other.m44, + ) + } +} + +/// Methods for creating and combining translation transformations +impl <T, Src, Dst> Transform3D<T, Src, Dst> +where + T: Zero + One, +{ + /// Create a 3d translation transform: + /// + /// ```text + /// 1 0 0 0 + /// 0 1 0 0 + /// 0 0 1 0 + /// x y z 1 + /// ``` + #[inline] + pub fn translation(x: T, y: T, z: T) -> Self { + let _0 = || T::zero(); + let _1 = || T::one(); + + Self::new( + _1(), _0(), _0(), _0(), + _0(), _1(), _0(), _0(), + _0(), _0(), _1(), _0(), + x, y, z, _1(), + ) + } + + /// Returns a transform with a translation applied before self's transformation. + #[must_use] + pub fn pre_translate(&self, v: Vector3D<T, Src>) -> Self + where + T: Copy + Add<Output = T> + Mul<Output = T>, + { + Transform3D::translation(v.x, v.y, v.z).then(self) + } + + /// Returns a transform with a translation applied after self's transformation. + #[must_use] + pub fn then_translate(&self, v: Vector3D<T, Dst>) -> Self + where + T: Copy + Add<Output = T> + Mul<Output = T>, + { + self.then(&Transform3D::translation(v.x, v.y, v.z)) + } +} + +/// Methods for creating and combining rotation transformations +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, +{ + /// Create a 3d rotation transform from an angle / axis. + /// The supplied axis must be normalized. + pub fn rotation(x: T, y: T, z: T, theta: Angle<T>) -> Self { + let (_0, _1): (T, T) = (Zero::zero(), One::one()); + let _2 = _1 + _1; + + let xx = x * x; + let yy = y * y; + let zz = z * z; + + let half_theta = theta.get() / _2; + let sc = half_theta.sin() * half_theta.cos(); + let sq = half_theta.sin() * half_theta.sin(); + + Transform3D::new( + _1 - _2 * (yy + zz) * sq, + _2 * (x * y * sq + z * sc), + _2 * (x * z * sq - y * sc), + _0, + + + _2 * (x * y * sq - z * sc), + _1 - _2 * (xx + zz) * sq, + _2 * (y * z * sq + x * sc), + _0, + + _2 * (x * z * sq + y * sc), + _2 * (y * z * sq - x * sc), + _1 - _2 * (xx + yy) * sq, + _0, + + _0, + _0, + _0, + _1 + ) + } + + /// Returns a transform with a rotation applied after self's transformation. + #[must_use] + pub fn then_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self { + self.then(&Transform3D::rotation(x, y, z, theta)) + } + + /// Returns a transform with a rotation applied before self's transformation. + #[must_use] + pub fn pre_rotate(&self, x: T, y: T, z: T, theta: Angle<T>) -> Self { + Transform3D::rotation(x, y, z, theta).then(self) + } +} + +/// Methods for creating and combining scale transformations +impl<T, Src, Dst> Transform3D<T, Src, Dst> +where + T: Zero + One, +{ + /// Create a 3d scale transform: + /// + /// ```text + /// x 0 0 0 + /// 0 y 0 0 + /// 0 0 z 0 + /// 0 0 0 1 + /// ``` + #[inline] + pub fn scale(x: T, y: T, z: T) -> Self { + let _0 = || T::zero(); + let _1 = || T::one(); + + Self::new( + x, _0(), _0(), _0(), + _0(), y, _0(), _0(), + _0(), _0(), z, _0(), + _0(), _0(), _0(), _1(), + ) + } + + /// Returns a transform with a scale applied before self's transformation. + #[must_use] + pub fn pre_scale(&self, x: T, y: T, z: T) -> Self + where + T: Copy + Add<Output = T> + Mul<Output = T>, + { + Transform3D::new( + self.m11 * x, self.m12 * x, self.m13 * x, self.m14 * x, + self.m21 * y, self.m22 * y, self.m23 * y, self.m24 * y, + self.m31 * z, self.m32 * z, self.m33 * z, self.m34 * z, + self.m41 , self.m42, self.m43, self.m44 + ) + } + + /// Returns a transform with a scale applied after self's transformation. + #[must_use] + pub fn then_scale(&self, x: T, y: T, z: T) -> Self + where + T: Copy + Add<Output = T> + Mul<Output = T>, + { + self.then(&Transform3D::scale(x, y, z)) + } +} + +/// Methods for apply transformations to objects +impl<T, Src, Dst> Transform3D<T, Src, Dst> +where + T: Copy + Add<Output = T> + Mul<Output = T>, +{ + /// 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. + #[inline] + pub fn transform_point2d_homogeneous( + &self, p: Point2D<T, Src> + ) -> HomogeneousVector<T, Dst> { + let x = p.x * self.m11 + p.y * self.m21 + self.m41; + let y = p.x * self.m12 + p.y * self.m22 + self.m42; + let z = p.x * self.m13 + p.y * self.m23 + self.m43; + let w = p.x * self.m14 + p.y * self.m24 + self.m44; + + HomogeneousVector::new(x, y, z, w) + } + + /// 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. + #[inline] + pub fn transform_point2d(&self, p: Point2D<T, Src>) -> Option<Point2D<T, Dst>> + where + T: Div<Output = T> + Zero + PartialOrd, + { + //Note: could use `transform_point2d_homogeneous()` but it would waste the calculus of `z` + let w = p.x * self.m14 + p.y * self.m24 + self.m44; + if w > T::zero() { + let x = p.x * self.m11 + p.y * self.m21 + self.m41; + let y = p.x * self.m12 + p.y * self.m22 + self.m42; + + Some(Point2D::new(x / w, y / w)) + } else { + None + } + } + + /// 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. + #[inline] + pub fn transform_vector2d(&self, v: Vector2D<T, Src>) -> Vector2D<T, Dst> { + vec2( + v.x * self.m11 + v.y * self.m21, + v.x * self.m12 + v.y * self.m22, + ) + } + + /// 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. + #[inline] + pub fn transform_point3d_homogeneous( + &self, p: Point3D<T, Src> + ) -> HomogeneousVector<T, Dst> { + let x = p.x * self.m11 + p.y * self.m21 + p.z * self.m31 + self.m41; + let y = p.x * self.m12 + p.y * self.m22 + p.z * self.m32 + self.m42; + let z = p.x * self.m13 + p.y * self.m23 + p.z * self.m33 + self.m43; + let w = p.x * self.m14 + p.y * self.m24 + p.z * self.m34 + self.m44; + + HomogeneousVector::new(x, y, z, w) + } + + /// 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. + #[inline] + pub fn transform_point3d(&self, p: Point3D<T, Src>) -> Option<Point3D<T, Dst>> + where + T: Div<Output = T> + Zero + PartialOrd, + { + self.transform_point3d_homogeneous(p).to_point3d() + } + + /// 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. + #[inline] + pub fn transform_vector3d(&self, v: Vector3D<T, Src>) -> Vector3D<T, Dst> { + vec3( + v.x * self.m11 + v.y * self.m21 + v.z * self.m31, + v.x * self.m12 + v.y * self.m22 + v.z * self.m32, + v.x * self.m13 + v.y * self.m23 + v.z * self.m33, + ) + } + + /// 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. + pub fn outer_transformed_rect(&self, rect: &Rect<T, Src>) -> Option<Rect<T, Dst>> + where + T: Sub<Output = T> + Div<Output = T> + Zero + PartialOrd, + { + let min = rect.min(); + let max = rect.max(); + Some(Rect::from_points(&[ + self.transform_point2d(min)?, + self.transform_point2d(max)?, + self.transform_point2d(point2(max.x, min.y))?, + self.transform_point2d(point2(min.x, max.y))?, + ])) + } + + /// Returns a 2d box that encompasses the result of transforming the given box by this + /// transform, if the transform makes sense for it, or `None` otherwise. + pub fn outer_transformed_box2d(&self, b: &Box2D<T, Src>) -> Option<Box2D<T, Dst>> + where + T: Sub<Output = T> + Div<Output = T> + Zero + PartialOrd, + { + Some(Box2D::from_points(&[ + self.transform_point2d(b.min)?, + self.transform_point2d(b.max)?, + self.transform_point2d(point2(b.max.x, b.min.y))?, + self.transform_point2d(point2(b.min.x, b.max.y))?, + ])) + } + + /// Returns a 3d box that encompasses the result of transforming the given box by this + /// transform, if the transform makes sense for it, or `None` otherwise. + pub fn outer_transformed_box3d(&self, b: &Box3D<T, Src>) -> Option<Box3D<T, Dst>> + where + T: Sub<Output = T> + Div<Output = T> + Zero + PartialOrd, + { + Some(Box3D::from_points(&[ + self.transform_point3d(point3(b.min.x, b.min.y, b.min.z))?, + self.transform_point3d(point3(b.min.x, b.min.y, b.max.z))?, + self.transform_point3d(point3(b.min.x, b.max.y, b.min.z))?, + self.transform_point3d(point3(b.min.x, b.max.y, b.max.z))?, + self.transform_point3d(point3(b.max.x, b.min.y, b.min.z))?, + self.transform_point3d(point3(b.max.x, b.min.y, b.max.z))?, + self.transform_point3d(point3(b.max.x, b.max.y, b.min.z))?, + self.transform_point3d(point3(b.max.x, b.max.y, b.max.z))?, + ])) + } +} + + +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 { + + /// Create an orthogonal projection transform. + pub fn ortho(left: T, right: T, + bottom: T, top: T, + near: T, far: T) -> Self { + let tx = -((right + left) / (right - left)); + let ty = -((top + bottom) / (top - bottom)); + let tz = -((far + near) / (far - near)); + + let (_0, _1): (T, T) = (Zero::zero(), One::one()); + let _2 = _1 + _1; + Transform3D::new( + _2 / (right - left), _0 , _0 , _0, + _0 , _2 / (top - bottom), _0 , _0, + _0 , _0 , -_2 / (far - near), _0, + tx , ty , tz , _1 + ) + } + + /// Check whether shapes on the XY plane with Z pointing towards the + /// screen transformed by this matrix would be facing back. + pub fn is_backface_visible(&self) -> bool { + // inverse().m33 < 0; + let det = self.determinant(); + let m33 = self.m12 * self.m24 * self.m41 - self.m14 * self.m22 * self.m41 + + self.m14 * self.m21 * self.m42 - self.m11 * self.m24 * self.m42 - + self.m12 * self.m21 * self.m44 + self.m11 * self.m22 * self.m44; + let _0: T = Zero::zero(); + (m33 * det) < _0 + } + + /// Returns whether it is possible to compute the inverse transform. + #[inline] + pub fn is_invertible(&self) -> bool { + self.determinant() != Zero::zero() + } + + /// Returns the inverse transform if possible. + pub fn inverse(&self) -> Option<Transform3D<T, Dst, Src>> { + let det = self.determinant(); + + if det == Zero::zero() { + return None; + } + + // todo(gw): this could be made faster by special casing + // for simpler transform types. + let m = Transform3D::new( + self.m23*self.m34*self.m42 - self.m24*self.m33*self.m42 + + self.m24*self.m32*self.m43 - self.m22*self.m34*self.m43 - + self.m23*self.m32*self.m44 + self.m22*self.m33*self.m44, + + self.m14*self.m33*self.m42 - self.m13*self.m34*self.m42 - + self.m14*self.m32*self.m43 + self.m12*self.m34*self.m43 + + self.m13*self.m32*self.m44 - self.m12*self.m33*self.m44, + + self.m13*self.m24*self.m42 - self.m14*self.m23*self.m42 + + self.m14*self.m22*self.m43 - self.m12*self.m24*self.m43 - + self.m13*self.m22*self.m44 + self.m12*self.m23*self.m44, + + self.m14*self.m23*self.m32 - self.m13*self.m24*self.m32 - + self.m14*self.m22*self.m33 + self.m12*self.m24*self.m33 + + self.m13*self.m22*self.m34 - self.m12*self.m23*self.m34, + + self.m24*self.m33*self.m41 - self.m23*self.m34*self.m41 - + self.m24*self.m31*self.m43 + self.m21*self.m34*self.m43 + + self.m23*self.m31*self.m44 - self.m21*self.m33*self.m44, + + self.m13*self.m34*self.m41 - self.m14*self.m33*self.m41 + + self.m14*self.m31*self.m43 - self.m11*self.m34*self.m43 - + self.m13*self.m31*self.m44 + self.m11*self.m33*self.m44, + + self.m14*self.m23*self.m41 - self.m13*self.m24*self.m41 - + self.m14*self.m21*self.m43 + self.m11*self.m24*self.m43 + + self.m13*self.m21*self.m44 - self.m11*self.m23*self.m44, + + self.m13*self.m24*self.m31 - self.m14*self.m23*self.m31 + + self.m14*self.m21*self.m33 - self.m11*self.m24*self.m33 - + self.m13*self.m21*self.m34 + self.m11*self.m23*self.m34, + + self.m22*self.m34*self.m41 - self.m24*self.m32*self.m41 + + self.m24*self.m31*self.m42 - self.m21*self.m34*self.m42 - + self.m22*self.m31*self.m44 + self.m21*self.m32*self.m44, + + self.m14*self.m32*self.m41 - self.m12*self.m34*self.m41 - + self.m14*self.m31*self.m42 + self.m11*self.m34*self.m42 + + self.m12*self.m31*self.m44 - self.m11*self.m32*self.m44, + + self.m12*self.m24*self.m41 - self.m14*self.m22*self.m41 + + self.m14*self.m21*self.m42 - self.m11*self.m24*self.m42 - + self.m12*self.m21*self.m44 + self.m11*self.m22*self.m44, + + self.m14*self.m22*self.m31 - self.m12*self.m24*self.m31 - + self.m14*self.m21*self.m32 + self.m11*self.m24*self.m32 + + self.m12*self.m21*self.m34 - self.m11*self.m22*self.m34, + + self.m23*self.m32*self.m41 - self.m22*self.m33*self.m41 - + self.m23*self.m31*self.m42 + self.m21*self.m33*self.m42 + + self.m22*self.m31*self.m43 - self.m21*self.m32*self.m43, + + self.m12*self.m33*self.m41 - self.m13*self.m32*self.m41 + + self.m13*self.m31*self.m42 - self.m11*self.m33*self.m42 - + self.m12*self.m31*self.m43 + self.m11*self.m32*self.m43, + + self.m13*self.m22*self.m41 - self.m12*self.m23*self.m41 - + self.m13*self.m21*self.m42 + self.m11*self.m23*self.m42 + + self.m12*self.m21*self.m43 - self.m11*self.m22*self.m43, + + self.m12*self.m23*self.m31 - self.m13*self.m22*self.m31 + + self.m13*self.m21*self.m32 - self.m11*self.m23*self.m32 - + self.m12*self.m21*self.m33 + self.m11*self.m22*self.m33 + ); + + let _1: T = One::one(); + Some(m.mul_s(_1 / det)) + } + + /// Compute the determinant of the transform. + pub fn determinant(&self) -> T { + self.m14 * self.m23 * self.m32 * self.m41 - + self.m13 * self.m24 * self.m32 * self.m41 - + self.m14 * self.m22 * self.m33 * self.m41 + + self.m12 * self.m24 * self.m33 * self.m41 + + self.m13 * self.m22 * self.m34 * self.m41 - + self.m12 * self.m23 * self.m34 * self.m41 - + self.m14 * self.m23 * self.m31 * self.m42 + + self.m13 * self.m24 * self.m31 * self.m42 + + self.m14 * self.m21 * self.m33 * self.m42 - + self.m11 * self.m24 * self.m33 * self.m42 - + self.m13 * self.m21 * self.m34 * self.m42 + + self.m11 * self.m23 * self.m34 * self.m42 + + self.m14 * self.m22 * self.m31 * self.m43 - + self.m12 * self.m24 * self.m31 * self.m43 - + self.m14 * self.m21 * self.m32 * self.m43 + + self.m11 * self.m24 * self.m32 * self.m43 + + self.m12 * self.m21 * self.m34 * self.m43 - + self.m11 * self.m22 * self.m34 * self.m43 - + self.m13 * self.m22 * self.m31 * self.m44 + + self.m12 * self.m23 * self.m31 * self.m44 + + self.m13 * self.m21 * self.m32 * self.m44 - + self.m11 * self.m23 * self.m32 * self.m44 - + self.m12 * self.m21 * self.m33 * self.m44 + + self.m11 * self.m22 * self.m33 * self.m44 + } + + /// Multiplies all of the transform's component by a scalar and returns the result. + #[must_use] + pub fn mul_s(&self, x: T) -> Self { + Transform3D::new( + self.m11 * x, self.m12 * x, self.m13 * x, self.m14 * x, + self.m21 * x, self.m22 * x, self.m23 * x, self.m24 * x, + self.m31 * x, self.m32 * x, self.m33 * x, self.m34 * x, + self.m41 * x, self.m42 * x, self.m43 * x, self.m44 * x + ) + } + + /// Convenience function to create a scale transform from a `Scale`. + pub fn from_scale(scale: Scale<T, Src, Dst>) -> Self { + Transform3D::scale(scale.get(), scale.get(), scale.get()) + } +} + +impl <T, Src, Dst> Transform3D<T, Src, Dst> +where + T: Copy + Mul<Output = T> + Div<Output = T> + Zero + One + PartialEq, +{ + /// Returns a projection of this transform in 2d space. + pub fn project_to_2d(&self) -> Self { + let (_0, _1): (T, T) = (Zero::zero(), One::one()); + + let mut result = self.clone(); + + result.m31 = _0; + result.m32 = _0; + result.m13 = _0; + result.m23 = _0; + result.m33 = _1; + result.m43 = _0; + result.m34 = _0; + + // Try to normalize perspective when possible to convert to a 2d matrix. + // Some matrices, such as those derived from perspective transforms, can + // modify m44 from 1, while leaving the rest of the fourth column + // (m14, m24) at 0. In this case, after resetting the third row and + // third column above, the value of m44 functions only to scale the + // coordinate transform divide by W. The matrix can be converted to + // a true 2D matrix by normalizing out the scaling effect of m44 on + // the remaining components ahead of time. + if self.m14 == _0 && self.m24 == _0 && self.m44 != _0 && self.m44 != _1 { + let scale = _1 / self.m44; + result.m11 = result.m11 * scale; + result.m12 = result.m12 * scale; + result.m21 = result.m21 * scale; + result.m22 = result.m22 * scale; + result.m41 = result.m41 * scale; + result.m42 = result.m42 * scale; + result.m44 = _1; + } + + result + } +} + +impl<T: NumCast + Copy, Src, Dst> Transform3D<T, Src, Dst> { + /// Cast from one numeric representation to another, preserving the units. + #[inline] + pub fn cast<NewT: NumCast>(&self) -> Transform3D<NewT, Src, Dst> { + self.try_cast().unwrap() + } + + /// Fallible cast from one numeric representation to another, preserving the units. + pub fn try_cast<NewT: NumCast>(&self) -> Option<Transform3D<NewT, Src, Dst>> { + match (NumCast::from(self.m11), NumCast::from(self.m12), + NumCast::from(self.m13), NumCast::from(self.m14), + NumCast::from(self.m21), NumCast::from(self.m22), + NumCast::from(self.m23), NumCast::from(self.m24), + NumCast::from(self.m31), NumCast::from(self.m32), + NumCast::from(self.m33), NumCast::from(self.m34), + NumCast::from(self.m41), NumCast::from(self.m42), + NumCast::from(self.m43), NumCast::from(self.m44)) { + (Some(m11), Some(m12), Some(m13), Some(m14), + Some(m21), Some(m22), Some(m23), Some(m24), + Some(m31), Some(m32), Some(m33), Some(m34), + Some(m41), Some(m42), Some(m43), Some(m44)) => { + Some(Transform3D::new(m11, m12, m13, m14, + m21, m22, m23, m24, + m31, m32, m33, m34, + m41, m42, m43, m44)) + }, + _ => None + } + } +} + +impl<T: ApproxEq<T>, Src, Dst> Transform3D<T, Src, Dst> { + /// 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. + /// + /// [`ApproxEq::approx_eq()`]: ./approxeq/trait.ApproxEq.html#method.approx_eq + #[inline] + pub fn approx_eq(&self, other: &Self) -> bool { + <Self as ApproxEq<T>>::approx_eq(&self, &other) + } + + /// 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. + /// + /// [`ApproxEq::approx_eq_eps()`]: ./approxeq/trait.ApproxEq.html#method.approx_eq_eps + #[inline] + pub fn approx_eq_eps(&self, other: &Self, eps: &T) -> bool { + <Self as ApproxEq<T>>::approx_eq_eps(&self, &other, &eps) + } +} + + +impl<T: ApproxEq<T>, Src, Dst> ApproxEq<T> for Transform3D<T, Src, Dst> { + #[inline] + fn approx_epsilon() -> T { T::approx_epsilon() } + + fn approx_eq_eps(&self, other: &Self, eps: &T) -> bool { + self.m11.approx_eq_eps(&other.m11, eps) && self.m12.approx_eq_eps(&other.m12, eps) && + self.m13.approx_eq_eps(&other.m13, eps) && self.m14.approx_eq_eps(&other.m14, eps) && + self.m21.approx_eq_eps(&other.m21, eps) && self.m22.approx_eq_eps(&other.m22, eps) && + self.m23.approx_eq_eps(&other.m23, eps) && self.m24.approx_eq_eps(&other.m24, eps) && + self.m31.approx_eq_eps(&other.m31, eps) && self.m32.approx_eq_eps(&other.m32, eps) && + self.m33.approx_eq_eps(&other.m33, eps) && self.m34.approx_eq_eps(&other.m34, eps) && + self.m41.approx_eq_eps(&other.m41, eps) && self.m42.approx_eq_eps(&other.m42, eps) && + self.m43.approx_eq_eps(&other.m43, eps) && self.m44.approx_eq_eps(&other.m44, eps) + } +} + +impl <T, Src, Dst> Default for Transform3D<T, Src, Dst> + where T: Zero + One +{ + /// Returns the [identity transform](#method.identity). + fn default() -> Self { + Self::identity() + } +} + +impl<T, Src, Dst> fmt::Debug for Transform3D<T, Src, Dst> +where T: Copy + fmt::Debug + + PartialEq + + One + Zero { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if self.is_identity() { + write!(f, "[I]") + } else { + self.to_array().fmt(f) + } + } +} + +#[cfg(feature = "mint")] +impl<T, Src, Dst> From<mint::RowMatrix4<T>> for Transform3D<T, Src, Dst> { + fn from(m: mint::RowMatrix4<T>) -> Self { + Transform3D { + m11: m.x.x, m12: m.x.y, m13: m.x.z, m14: m.x.w, + m21: m.y.x, m22: m.y.y, m23: m.y.z, m24: m.y.w, + m31: m.z.x, m32: m.z.y, m33: m.z.z, m34: m.z.w, + m41: m.w.x, m42: m.w.y, m43: m.w.z, m44: m.w.w, + _unit: PhantomData, + } + } +} +#[cfg(feature = "mint")] +impl<T, Src, Dst> Into<mint::RowMatrix4<T>> for Transform3D<T, Src, Dst> { + fn into(self) -> mint::RowMatrix4<T> { + mint::RowMatrix4 { + x: mint::Vector4 { x: self.m11, y: self.m12, z: self.m13, w: self.m14 }, + y: mint::Vector4 { x: self.m21, y: self.m22, z: self.m23, w: self.m24 }, + z: mint::Vector4 { x: self.m31, y: self.m32, z: self.m33, w: self.m34 }, + w: mint::Vector4 { x: self.m41, y: self.m42, z: self.m43, w: self.m44 }, + } + } +} + + +#[cfg(test)] +mod tests { + use crate::approxeq::ApproxEq; + use super::*; + use crate::{point2, point3}; + use crate::default; + + use core::f32::consts::{FRAC_PI_2, PI}; + + type Mf32 = default::Transform3D<f32>; + + // For convenience. + fn rad(v: f32) -> Angle<f32> { Angle::radians(v) } + + #[test] + pub fn test_translation() { + let t1 = Mf32::translation(1.0, 2.0, 3.0); + let t2 = Mf32::identity().pre_translate(vec3(1.0, 2.0, 3.0)); + let t3 = Mf32::identity().then_translate(vec3(1.0, 2.0, 3.0)); + assert_eq!(t1, t2); + assert_eq!(t1, t3); + + assert_eq!(t1.transform_point3d(point3(1.0, 1.0, 1.0)), Some(point3(2.0, 3.0, 4.0))); + assert_eq!(t1.transform_point2d(point2(1.0, 1.0)), Some(point2(2.0, 3.0))); + + assert_eq!(t1.then(&t1), Mf32::translation(2.0, 4.0, 6.0)); + + assert!(!t1.is_2d()); + assert_eq!(Mf32::translation(1.0, 2.0, 3.0).to_2d(), Transform2D::translation(1.0, 2.0)); + } + + #[test] + pub fn test_rotation() { + let r1 = Mf32::rotation(0.0, 0.0, 1.0, rad(FRAC_PI_2)); + let r2 = Mf32::identity().pre_rotate(0.0, 0.0, 1.0, rad(FRAC_PI_2)); + let r3 = Mf32::identity().then_rotate(0.0, 0.0, 1.0, rad(FRAC_PI_2)); + assert_eq!(r1, r2); + assert_eq!(r1, r3); + + assert!(r1.transform_point3d(point3(1.0, 2.0, 3.0)).unwrap().approx_eq(&point3(-2.0, 1.0, 3.0))); + assert!(r1.transform_point2d(point2(1.0, 2.0)).unwrap().approx_eq(&point2(-2.0, 1.0))); + + assert!(r1.then(&r1).approx_eq(&Mf32::rotation(0.0, 0.0, 1.0, rad(FRAC_PI_2*2.0)))); + + assert!(r1.is_2d()); + assert!(r1.to_2d().approx_eq(&Transform2D::rotation(rad(FRAC_PI_2)))); + } + + #[test] + pub fn test_scale() { + let s1 = Mf32::scale(2.0, 3.0, 4.0); + let s2 = Mf32::identity().pre_scale(2.0, 3.0, 4.0); + let s3 = Mf32::identity().then_scale(2.0, 3.0, 4.0); + assert_eq!(s1, s2); + assert_eq!(s1, s3); + + assert!(s1.transform_point3d(point3(2.0, 2.0, 2.0)).unwrap().approx_eq(&point3(4.0, 6.0, 8.0))); + assert!(s1.transform_point2d(point2(2.0, 2.0)).unwrap().approx_eq(&point2(4.0, 6.0))); + + assert_eq!(s1.then(&s1), Mf32::scale(4.0, 9.0, 16.0)); + + assert!(!s1.is_2d()); + assert_eq!(Mf32::scale(2.0, 3.0, 0.0).to_2d(), Transform2D::scale(2.0, 3.0)); + } + + + #[test] + pub fn test_pre_then_scale() { + let m = Mf32::rotation(0.0, 0.0, 1.0, rad(FRAC_PI_2)).then_translate(vec3(6.0, 7.0, 8.0)); + let s = Mf32::scale(2.0, 3.0, 4.0); + assert_eq!(m.then(&s), m.then_scale(2.0, 3.0, 4.0)); + } + + + #[test] + pub fn test_ortho() { + let (left, right, bottom, top) = (0.0f32, 1.0f32, 0.1f32, 1.0f32); + let (near, far) = (-1.0f32, 1.0f32); + let result = Mf32::ortho(left, right, bottom, top, near, far); + let expected = Mf32::new( + 2.0, 0.0, 0.0, 0.0, + 0.0, 2.22222222, 0.0, 0.0, + 0.0, 0.0, -1.0, 0.0, + -1.0, -1.22222222, -0.0, 1.0 + ); + assert!(result.approx_eq(&expected)); + } + + #[test] + pub fn test_is_2d() { + assert!(Mf32::identity().is_2d()); + assert!(Mf32::rotation(0.0, 0.0, 1.0, rad(0.7854)).is_2d()); + assert!(!Mf32::rotation(0.0, 1.0, 0.0, rad(0.7854)).is_2d()); + } + + #[test] + pub fn test_new_2d() { + let m1 = Mf32::new_2d(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); + let m2 = Mf32::new( + 1.0, 2.0, 0.0, 0.0, + 3.0, 4.0, 0.0, 0.0, + 0.0, 0.0, 1.0, 0.0, + 5.0, 6.0, 0.0, 1.0 + ); + assert_eq!(m1, m2); + } + + #[test] + pub fn test_inverse_simple() { + let m1 = Mf32::identity(); + let m2 = m1.inverse().unwrap(); + assert!(m1.approx_eq(&m2)); + } + + #[test] + pub fn test_inverse_scale() { + let m1 = Mf32::scale(1.5, 0.3, 2.1); + let m2 = m1.inverse().unwrap(); + assert!(m1.then(&m2).approx_eq(&Mf32::identity())); + assert!(m2.then(&m1).approx_eq(&Mf32::identity())); + } + + #[test] + pub fn test_inverse_translate() { + let m1 = Mf32::translation(-132.0, 0.3, 493.0); + let m2 = m1.inverse().unwrap(); + assert!(m1.then(&m2).approx_eq(&Mf32::identity())); + assert!(m2.then(&m1).approx_eq(&Mf32::identity())); + } + + #[test] + pub fn test_inverse_rotate() { + let m1 = Mf32::rotation(0.0, 1.0, 0.0, rad(1.57)); + let m2 = m1.inverse().unwrap(); + assert!(m1.then(&m2).approx_eq(&Mf32::identity())); + assert!(m2.then(&m1).approx_eq(&Mf32::identity())); + } + + #[test] + pub fn test_inverse_transform_point_2d() { + let m1 = Mf32::translation(100.0, 200.0, 0.0); + let m2 = m1.inverse().unwrap(); + assert!(m1.then(&m2).approx_eq(&Mf32::identity())); + assert!(m2.then(&m1).approx_eq(&Mf32::identity())); + + let p1 = point2(1000.0, 2000.0); + let p2 = m1.transform_point2d(p1); + assert_eq!(p2, Some(point2(1100.0, 2200.0))); + + let p3 = m2.transform_point2d(p2.unwrap()); + assert_eq!(p3, Some(p1)); + } + + #[test] + fn test_inverse_none() { + assert!(Mf32::scale(2.0, 0.0, 2.0).inverse().is_none()); + assert!(Mf32::scale(2.0, 2.0, 2.0).inverse().is_some()); + } + + #[test] + pub fn test_pre_post() { + let m1 = default::Transform3D::identity().then_scale(1.0, 2.0, 3.0).then_translate(vec3(1.0, 2.0, 3.0)); + let m2 = default::Transform3D::identity().pre_translate(vec3(1.0, 2.0, 3.0)).pre_scale(1.0, 2.0, 3.0); + assert!(m1.approx_eq(&m2)); + + let r = Mf32::rotation(0.0, 0.0, 1.0, rad(FRAC_PI_2)); + let t = Mf32::translation(2.0, 3.0, 0.0); + + let a = point3(1.0, 1.0, 1.0); + + assert!(r.then(&t).transform_point3d(a).unwrap().approx_eq(&point3(1.0, 4.0, 1.0))); + assert!(t.then(&r).transform_point3d(a).unwrap().approx_eq(&point3(-4.0, 3.0, 1.0))); + assert!(t.then(&r).transform_point3d(a).unwrap().approx_eq(&r.transform_point3d(t.transform_point3d(a).unwrap()).unwrap())); + } + + #[test] + fn test_size_of() { + use core::mem::size_of; + assert_eq!(size_of::<default::Transform3D<f32>>(), 16*size_of::<f32>()); + assert_eq!(size_of::<default::Transform3D<f64>>(), 16*size_of::<f64>()); + } + + #[test] + pub fn test_transform_associativity() { + let m1 = Mf32::new(3.0, 2.0, 1.5, 1.0, + 0.0, 4.5, -1.0, -4.0, + 0.0, 3.5, 2.5, 40.0, + 0.0, 3.0, 0.0, 1.0); + let m2 = Mf32::new(1.0, -1.0, 3.0, 0.0, + -1.0, 0.5, 0.0, 2.0, + 1.5, -2.0, 6.0, 0.0, + -2.5, 6.0, 1.0, 1.0); + + let p = point3(1.0, 3.0, 5.0); + let p1 = m1.then(&m2).transform_point3d(p).unwrap(); + let p2 = m2.transform_point3d(m1.transform_point3d(p).unwrap()).unwrap(); + assert!(p1.approx_eq(&p2)); + } + + #[test] + pub fn test_is_identity() { + let m1 = default::Transform3D::identity(); + assert!(m1.is_identity()); + let m2 = m1.then_translate(vec3(0.1, 0.0, 0.0)); + assert!(!m2.is_identity()); + } + + #[test] + pub fn test_transform_vector() { + // Translation does not apply to vectors. + let m = Mf32::translation(1.0, 2.0, 3.0); + let v1 = vec3(10.0, -10.0, 3.0); + assert_eq!(v1, m.transform_vector3d(v1)); + // While it does apply to points. + assert_ne!(Some(v1.to_point()), m.transform_point3d(v1.to_point())); + + // same thing with 2d vectors/points + let v2 = vec2(10.0, -5.0); + assert_eq!(v2, m.transform_vector2d(v2)); + assert_ne!(Some(v2.to_point()), m.transform_point2d(v2.to_point())); + } + + #[test] + pub fn test_is_backface_visible() { + // backface is not visible for rotate-x 0 degree. + let r1 = Mf32::rotation(1.0, 0.0, 0.0, rad(0.0)); + assert!(!r1.is_backface_visible()); + // backface is not visible for rotate-x 45 degree. + let r1 = Mf32::rotation(1.0, 0.0, 0.0, rad(PI * 0.25)); + assert!(!r1.is_backface_visible()); + // backface is visible for rotate-x 180 degree. + let r1 = Mf32::rotation(1.0, 0.0, 0.0, rad(PI)); + assert!(r1.is_backface_visible()); + // backface is visible for rotate-x 225 degree. + let r1 = Mf32::rotation(1.0, 0.0, 0.0, rad(PI * 1.25)); + assert!(r1.is_backface_visible()); + // backface is not visible for non-inverseable matrix + let r1 = Mf32::scale(2.0, 0.0, 2.0); + assert!(!r1.is_backface_visible()); + } + + #[test] + pub fn test_homogeneous() { + let m = Mf32::new( + 1.0, 2.0, 0.5, 5.0, + 3.0, 4.0, 0.25, 6.0, + 0.5, -1.0, 1.0, -1.0, + -1.0, 1.0, -1.0, 2.0, + ); + assert_eq!( + m.transform_point2d_homogeneous(point2(1.0, 2.0)), + HomogeneousVector::new(6.0, 11.0, 0.0, 19.0), + ); + assert_eq!( + m.transform_point3d_homogeneous(point3(1.0, 2.0, 4.0)), + HomogeneousVector::new(8.0, 7.0, 4.0, 15.0), + ); + } + + #[test] + pub fn test_perspective_division() { + let p = point2(1.0, 2.0); + let mut m = Mf32::identity(); + assert!(m.transform_point2d(p).is_some()); + m.m44 = 0.0; + assert_eq!(None, m.transform_point2d(p)); + m.m44 = 1.0; + m.m24 = -1.0; + assert_eq!(None, m.transform_point2d(p)); + } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let m1 = Mf32::rotation(0.0, 0.0, 1.0, rad(FRAC_PI_2)); + let mm: mint::RowMatrix4<_> = m1.into(); + let m2 = Mf32::from(mm); + + assert_eq!(m1, m2); + } +} |