diff options
Diffstat (limited to 'third_party/rust/euclid/src/transform2d.rs')
| -rw-r--r-- | third_party/rust/euclid/src/transform2d.rs | 809 |
1 files changed, 809 insertions, 0 deletions
diff --git a/third_party/rust/euclid/src/transform2d.rs b/third_party/rust/euclid/src/transform2d.rs new file mode 100644 index 0000000000..85eb426b6c --- /dev/null +++ b/third_party/rust/euclid/src/transform2d.rs @@ -0,0 +1,809 @@ +// 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}; +#[cfg(feature = "mint")] +use mint; +use crate::num::{One, Zero}; +use crate::point::{Point2D, point2}; +use crate::vector::{Vector2D, vec2}; +use crate::rect::Rect; +use crate::box2d::Box2D; +use crate::transform3d::Transform3D; +use core::ops::{Add, Mul, Div, Sub}; +use core::marker::PhantomData; +use core::cmp::{Eq, PartialEq}; +use core::hash::{Hash}; +use crate::approxeq::ApproxEq; +use crate::trig::Trig; +use core::fmt; +use num_traits::NumCast; +#[cfg(feature = "serde")] +use serde::{Deserialize, Serialize}; +#[cfg(feature = "bytemuck")] +use bytemuck::{Zeroable, Pod}; + +/// A 2d transform represented by a column-major 3 by 3 matrix, compressed down to 3 by 2. +/// +/// Transforms can be parametrized over the source and destination units, to describe a +/// transformation from a space to another. +/// For example, `Transform2D<f32, WorldSpace, ScreenSpace>::transform_point4d` +/// takes a `Point2D<f32, WorldSpace>` and returns a `Point2D<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. +/// +/// The matrix representation is conceptually equivalent to a 3 by 3 matrix transformation +/// compressed to 3 by 2 with the components that aren't needed to describe the set of 2d +/// transformations we are interested in implicitly defined: +/// +/// ```text +/// | m11 m12 0 | |x| |x'| +/// | m21 m22 0 | x |y| = |y'| +/// | m31 m32 1 | |1| |w | +/// ``` +/// +/// When translating Transform2D into general matrix representations, consider that the +/// representation follows the column-major notation with column vectors. +/// +/// The translation terms are m31 and m32. +#[repr(C)] +#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr( + feature = "serde", + serde(bound(serialize = "T: Serialize", deserialize = "T: Deserialize<'de>")) +)] +pub struct Transform2D<T, Src, Dst> { + pub m11: T, pub m12: T, + pub m21: T, pub m22: T, + pub m31: T, pub m32: T, + #[doc(hidden)] + pub _unit: PhantomData<(Src, Dst)>, +} + +#[cfg(feature = "arbitrary")] +impl<'a, T, Src, Dst> arbitrary::Arbitrary<'a> for Transform2D<T, Src, Dst> +where + T: arbitrary::Arbitrary<'a>, +{ + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> + { + let (m11, m12, m21, m22, m31, m32) = arbitrary::Arbitrary::arbitrary(u)?; + Ok(Transform2D { + m11, m12, m21, m22, m31, m32, + _unit: PhantomData, + }) + } +} + +#[cfg(feature = "bytemuck")] +unsafe impl<T: Zeroable, Src, Dst> Zeroable for Transform2D<T, Src, Dst> {} + +#[cfg(feature = "bytemuck")] +unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for Transform2D<T, Src, Dst> {} + +impl<T: Copy, Src, Dst> Copy for Transform2D<T, Src, Dst> {} + +impl<T: Clone, Src, Dst> Clone for Transform2D<T, Src, Dst> { + fn clone(&self) -> Self { + Transform2D { + m11: self.m11.clone(), + m12: self.m12.clone(), + m21: self.m21.clone(), + m22: self.m22.clone(), + m31: self.m31.clone(), + m32: self.m32.clone(), + _unit: PhantomData, + } + } +} + +impl<T, Src, Dst> Eq for Transform2D<T, Src, Dst> where T: Eq {} + +impl<T, Src, Dst> PartialEq for Transform2D<T, Src, Dst> + where T: PartialEq +{ + fn eq(&self, other: &Self) -> bool { + self.m11 == other.m11 && + self.m12 == other.m12 && + self.m21 == other.m21 && + self.m22 == other.m22 && + self.m31 == other.m31 && + self.m32 == other.m32 + } +} + +impl<T, Src, Dst> Hash for Transform2D<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.m21.hash(h); + self.m22.hash(h); + self.m31.hash(h); + self.m32.hash(h); + } +} + + +impl<T, Src, Dst> Transform2D<T, Src, Dst> { + /// Create a transform specifying its components in using the column-major-column-vector + /// matrix notation. + /// + /// For example, the translation terms m31 and m32 are the last two parameters parameters. + /// + /// ``` + /// use euclid::default::Transform2D; + /// let tx = 1.0; + /// let ty = 2.0; + /// let translation = Transform2D::new( + /// 1.0, 0.0, + /// 0.0, 1.0, + /// tx, ty, + /// ); + /// ``` + pub const fn new(m11: T, m12: T, m21: T, m22: T, m31: T, m32: T) -> Self { + Transform2D { + m11, m12, + m21, m22, + m31, m32, + _unit: PhantomData, + } + } + + /// 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 + where T : ApproxEq<T> { + <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 + where T : ApproxEq<T> { + <Self as ApproxEq<T>>::approx_eq_eps(&self, &other, &eps) + } +} + +impl<T: Copy, Src, Dst> Transform2D<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 `Transform2D::new`, that is following the + /// column-major-column-vector matrix notation. + /// + /// For example the translation terms are found in the + /// last two slots of the array. + #[inline] + pub fn to_array(&self) -> [T; 6] { + [ + self.m11, self.m12, + self.m21, self.m22, + self.m31, self.m32 + ] + } + + /// 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 2 and 5 + /// in the array. + #[inline] + pub fn to_array_transposed(&self) -> [T; 6] { + [ + self.m11, self.m21, self.m31, + self.m12, self.m22, self.m32 + ] + } + + /// Equivalent to `to_array` with elements packed two at a time + /// in an array of arrays. + #[inline] + pub fn to_arrays(&self) -> [[T; 2]; 3] { + [ + [self.m11, self.m12], + [self.m21, self.m22], + [self.m31, self.m32], + ] + } + + /// Create a transform providing its components via an array + /// of 6 elements instead of as individual parameters. + /// + /// The order of the components corresponds to the + /// column-major-column-vector matrix notation (the same order + /// as `Transform2D::new`). + #[inline] + pub fn from_array(array: [T; 6]) -> Self { + Self::new( + array[0], array[1], + array[2], array[3], + array[4], array[5], + ) + } + + /// Equivalent to `from_array` with elements packed two 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; 2]; 3]) -> Self { + Self::new( + array[0][0], array[0][1], + array[1][0], array[1][1], + array[2][0], array[2][1], + ) + } + + /// Drop the units, preserving only the numeric value. + #[inline] + pub fn to_untyped(&self) -> Transform2D<T, UnknownUnit, UnknownUnit> { + Transform2D::new( + self.m11, self.m12, + self.m21, self.m22, + self.m31, self.m32 + ) + } + + /// Tag a unitless value with units. + #[inline] + pub fn from_untyped(p: &Transform2D<T, UnknownUnit, UnknownUnit>) -> Self { + Transform2D::new( + p.m11, p.m12, + p.m21, p.m22, + p.m31, p.m32 + ) + } + + /// Returns the same transform with a different source unit. + #[inline] + pub fn with_source<NewSrc>(&self) -> Transform2D<T, NewSrc, Dst> { + Transform2D::new( + self.m11, self.m12, + self.m21, self.m22, + self.m31, self.m32, + ) + } + + /// Returns the same transform with a different destination unit. + #[inline] + pub fn with_destination<NewDst>(&self) -> Transform2D<T, Src, NewDst> { + Transform2D::new( + self.m11, self.m12, + self.m21, self.m22, + self.m31, self.m32, + ) + } + + /// Create a 3D transform from the current transform + pub fn to_3d(&self) -> Transform3D<T, Src, Dst> + where + T: Zero + One, + { + Transform3D::new_2d(self.m11, self.m12, self.m21, self.m22, self.m31, self.m32) + } +} + +impl<T: NumCast + Copy, Src, Dst> Transform2D<T, Src, Dst> { + /// Cast from one numeric representation to another, preserving the units. + #[inline] + pub fn cast<NewT: NumCast>(&self) -> Transform2D<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<Transform2D<NewT, Src, Dst>> { + match (NumCast::from(self.m11), NumCast::from(self.m12), + NumCast::from(self.m21), NumCast::from(self.m22), + NumCast::from(self.m31), NumCast::from(self.m32)) { + (Some(m11), Some(m12), + Some(m21), Some(m22), + Some(m31), Some(m32)) => { + Some(Transform2D::new( + m11, m12, + m21, m22, + m31, m32 + )) + }, + _ => None + } + } +} + +impl<T, Src, Dst> Transform2D<T, Src, Dst> +where + T: Zero + One, +{ + /// Create an identity matrix: + /// + /// ```text + /// 1 0 + /// 0 1 + /// 0 0 + /// ``` + #[inline] + pub fn identity() -> Self { + Self::translation(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. + fn is_identity(&self) -> bool + where + T: PartialEq, + { + *self == Self::identity() + } +} + + +/// Methods for combining generic transformations +impl<T, Src, Dst> Transform2D<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. + #[must_use] + pub fn then<NewDst>(&self, mat: &Transform2D<T, Dst, NewDst>) -> Transform2D<T, Src, NewDst> { + Transform2D::new( + self.m11 * mat.m11 + self.m12 * mat.m21, + self.m11 * mat.m12 + self.m12 * mat.m22, + + self.m21 * mat.m11 + self.m22 * mat.m21, + self.m21 * mat.m12 + self.m22 * mat.m22, + + self.m31 * mat.m11 + self.m32 * mat.m21 + mat.m31, + self.m31 * mat.m12 + self.m32 * mat.m22 + mat.m32, + ) + } +} + +/// Methods for creating and combining translation transformations +impl<T, Src, Dst> Transform2D<T, Src, Dst> +where + T: Zero + One, +{ + /// Create a 2d translation transform: + /// + /// ```text + /// 1 0 + /// 0 1 + /// x y + /// ``` + #[inline] + pub fn translation(x: T, y: T) -> Self { + let _0 = || T::zero(); + let _1 = || T::one(); + + Self::new( + _1(), _0(), + _0(), _1(), + x, y, + ) + } + + /// Applies a translation after self's transformation and returns the resulting transform. + #[inline] + #[must_use] + pub fn then_translate(&self, v: Vector2D<T, Dst>) -> Self + where + T: Copy + Add<Output = T> + Mul<Output = T>, + { + self.then(&Transform2D::translation(v.x, v.y)) + } + + /// Applies a translation before self's transformation and returns the resulting transform. + #[inline] + #[must_use] + pub fn pre_translate(&self, v: Vector2D<T, Src>) -> Self + where + T: Copy + Add<Output = T> + Mul<Output = T>, + { + Transform2D::translation(v.x, v.y).then(self) + } +} + +/// Methods for creating and combining rotation transformations +impl<T, Src, Dst> Transform2D<T, Src, Dst> +where + T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Zero + Trig, +{ + /// Returns a rotation transform. + #[inline] + pub fn rotation(theta: Angle<T>) -> Self { + let _0 = Zero::zero(); + let cos = theta.get().cos(); + let sin = theta.get().sin(); + Transform2D::new( + cos, sin, + _0 - sin, cos, + _0, _0 + ) + } + + /// Applies a rotation after self's transformation and returns the resulting transform. + #[inline] + #[must_use] + pub fn then_rotate(&self, theta: Angle<T>) -> Self { + self.then(&Transform2D::rotation(theta)) + } + + /// Applies a rotation before self's transformation and returns the resulting transform. + #[inline] + #[must_use] + pub fn pre_rotate(&self, theta: Angle<T>) -> Self { + Transform2D::rotation(theta).then(self) + } +} + +/// Methods for creating and combining scale transformations +impl<T, Src, Dst> Transform2D<T, Src, Dst> { + /// Create a 2d scale transform: + /// + /// ```text + /// x 0 + /// 0 y + /// 0 0 + /// ``` + #[inline] + pub fn scale(x: T, y: T) -> Self + where + T: Zero, + { + let _0 = || Zero::zero(); + + Self::new( + x, _0(), + _0(), y, + _0(), _0(), + ) + } + + /// Applies a scale after self's transformation and returns the resulting transform. + #[inline] + #[must_use] + pub fn then_scale(&self, x: T, y: T) -> Self + where + T: Copy + Add<Output = T> + Mul<Output = T> + Zero, + { + self.then(&Transform2D::scale(x, y)) + } + + /// Applies a scale before self's transformation and returns the resulting transform. + #[inline] + #[must_use] + pub fn pre_scale(&self, x: T, y: T) -> Self + where + T: Copy + Mul<Output = T>, + { + Transform2D::new( + self.m11 * x, self.m12 * x, + self.m21 * y, self.m22 * y, + self.m31, self.m32 + ) + } +} + +/// Methods for apply transformations to objects +impl<T, Src, Dst> Transform2D<T, Src, Dst> +where + T: Copy + Add<Output = T> + Mul<Output = T>, +{ + /// Returns the given point transformed by this transform. + #[inline] + #[must_use] + pub fn transform_point(&self, point: Point2D<T, Src>) -> Point2D<T, Dst> { + Point2D::new( + point.x * self.m11 + point.y * self.m21 + self.m31, + point.x * self.m12 + point.y * self.m22 + self.m32 + ) + } + + /// Returns the given vector transformed by this matrix. + #[inline] + #[must_use] + pub fn transform_vector(&self, vec: Vector2D<T, Src>) -> Vector2D<T, Dst> { + vec2(vec.x * self.m11 + vec.y * self.m21, + vec.x * self.m12 + vec.y * self.m22) + } + + /// Returns a rectangle that encompasses the result of transforming the given rectangle by this + /// transform. + #[inline] + #[must_use] + pub fn outer_transformed_rect(&self, rect: &Rect<T, Src>) -> Rect<T, Dst> + where + T: Sub<Output = T> + Zero + PartialOrd, + { + let min = rect.min(); + let max = rect.max(); + Rect::from_points(&[ + self.transform_point(min), + self.transform_point(max), + self.transform_point(point2(max.x, min.y)), + self.transform_point(point2(min.x, max.y)), + ]) + } + + + /// Returns a box that encompasses the result of transforming the given box by this + /// transform. + #[inline] + #[must_use] + pub fn outer_transformed_box(&self, b: &Box2D<T, Src>) -> Box2D<T, Dst> + where + T: Sub<Output = T> + Zero + PartialOrd, + { + Box2D::from_points(&[ + self.transform_point(b.min), + self.transform_point(b.max), + self.transform_point(point2(b.max.x, b.min.y)), + self.transform_point(point2(b.min.x, b.max.y)), + ]) + } +} + + +impl<T, Src, Dst> Transform2D<T, Src, Dst> +where + T: Copy + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + PartialEq + Zero + One, +{ + /// Computes and returns the determinant of this transform. + pub fn determinant(&self) -> T { + self.m11 * self.m22 - self.m12 * self.m21 + } + + /// 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. + #[must_use] + pub fn inverse(&self) -> Option<Transform2D<T, Dst, Src>> { + let det = self.determinant(); + + let _0: T = Zero::zero(); + let _1: T = One::one(); + + if det == _0 { + return None; + } + + let inv_det = _1 / det; + Some(Transform2D::new( + inv_det * self.m22, + inv_det * (_0 - self.m12), + inv_det * (_0 - self.m21), + inv_det * self.m11, + inv_det * (self.m21 * self.m32 - self.m22 * self.m31), + inv_det * (self.m31 * self.m12 - self.m11 * self.m32), + )) + } +} + +impl <T, Src, Dst> Default for Transform2D<T, Src, Dst> + where T: Zero + One +{ + /// Returns the [identity transform](#method.identity). + fn default() -> Self { + Self::identity() + } +} + +impl<T: ApproxEq<T>, Src, Dst> ApproxEq<T> for Transform2D<T, Src, Dst> { + #[inline] + fn approx_epsilon() -> T { T::approx_epsilon() } + + /// Returns true is this transform is approximately equal to the other one, using + /// a provided epsilon value. + 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.m21.approx_eq_eps(&other.m21, eps) && self.m22.approx_eq_eps(&other.m22, eps) && + self.m31.approx_eq_eps(&other.m31, eps) && self.m32.approx_eq_eps(&other.m32, eps) + } +} + +impl<T, Src, Dst> fmt::Debug for Transform2D<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::RowMatrix3x2<T>> for Transform2D<T, Src, Dst> { + fn from(m: mint::RowMatrix3x2<T>) -> Self { + Transform2D { + m11: m.x.x, m12: m.x.y, + m21: m.y.x, m22: m.y.y, + m31: m.z.x, m32: m.z.y, + _unit: PhantomData, + } + } +} +#[cfg(feature = "mint")] +impl<T, Src, Dst> Into<mint::RowMatrix3x2<T>> for Transform2D<T, Src, Dst> { + fn into(self) -> mint::RowMatrix3x2<T> { + mint::RowMatrix3x2 { + x: mint::Vector2 { x: self.m11, y: self.m12 }, + y: mint::Vector2 { x: self.m21, y: self.m22 }, + z: mint::Vector2 { x: self.m31, y: self.m32 }, + } + } +} + + +#[cfg(test)] +mod test { + use super::*; + use crate::default; + use crate::approxeq::ApproxEq; + #[cfg(feature = "mint")] + use mint; + + use core::f32::consts::FRAC_PI_2; + + type Mat = default::Transform2D<f32>; + + fn rad(v: f32) -> Angle<f32> { Angle::radians(v) } + + #[test] + pub fn test_translation() { + let t1 = Mat::translation(1.0, 2.0); + let t2 = Mat::identity().pre_translate(vec2(1.0, 2.0)); + let t3 = Mat::identity().then_translate(vec2(1.0, 2.0)); + assert_eq!(t1, t2); + assert_eq!(t1, t3); + + assert_eq!(t1.transform_point(Point2D::new(1.0, 1.0)), Point2D::new(2.0, 3.0)); + + assert_eq!(t1.then(&t1), Mat::translation(2.0, 4.0)); + } + + #[test] + pub fn test_rotation() { + let r1 = Mat::rotation(rad(FRAC_PI_2)); + let r2 = Mat::identity().pre_rotate(rad(FRAC_PI_2)); + let r3 = Mat::identity().then_rotate(rad(FRAC_PI_2)); + assert_eq!(r1, r2); + assert_eq!(r1, r3); + + assert!(r1.transform_point(Point2D::new(1.0, 2.0)).approx_eq(&Point2D::new(-2.0, 1.0))); + + assert!(r1.then(&r1).approx_eq(&Mat::rotation(rad(FRAC_PI_2*2.0)))); + } + + #[test] + pub fn test_scale() { + let s1 = Mat::scale(2.0, 3.0); + let s2 = Mat::identity().pre_scale(2.0, 3.0); + let s3 = Mat::identity().then_scale(2.0, 3.0); + assert_eq!(s1, s2); + assert_eq!(s1, s3); + + assert!(s1.transform_point(Point2D::new(2.0, 2.0)).approx_eq(&Point2D::new(4.0, 6.0))); + } + + + #[test] + pub fn test_pre_then_scale() { + let m = Mat::rotation(rad(FRAC_PI_2)).then_translate(vec2(6.0, 7.0)); + let s = Mat::scale(2.0, 3.0); + assert_eq!(m.then(&s), m.then_scale(2.0, 3.0)); + } + + #[test] + pub fn test_inverse_simple() { + let m1 = Mat::identity(); + let m2 = m1.inverse().unwrap(); + assert!(m1.approx_eq(&m2)); + } + + #[test] + pub fn test_inverse_scale() { + let m1 = Mat::scale(1.5, 0.3); + let m2 = m1.inverse().unwrap(); + assert!(m1.then(&m2).approx_eq(&Mat::identity())); + assert!(m2.then(&m1).approx_eq(&Mat::identity())); + } + + #[test] + pub fn test_inverse_translate() { + let m1 = Mat::translation(-132.0, 0.3); + let m2 = m1.inverse().unwrap(); + assert!(m1.then(&m2).approx_eq(&Mat::identity())); + assert!(m2.then(&m1).approx_eq(&Mat::identity())); + } + + #[test] + fn test_inverse_none() { + assert!(Mat::scale(2.0, 0.0).inverse().is_none()); + assert!(Mat::scale(2.0, 2.0).inverse().is_some()); + } + + #[test] + pub fn test_pre_post() { + let m1 = default::Transform2D::identity().then_scale(1.0, 2.0).then_translate(vec2(1.0, 2.0)); + let m2 = default::Transform2D::identity().pre_translate(vec2(1.0, 2.0)).pre_scale(1.0, 2.0); + assert!(m1.approx_eq(&m2)); + + let r = Mat::rotation(rad(FRAC_PI_2)); + let t = Mat::translation(2.0, 3.0); + + let a = Point2D::new(1.0, 1.0); + + assert!(r.then(&t).transform_point(a).approx_eq(&Point2D::new(1.0, 4.0))); + assert!(t.then(&r).transform_point(a).approx_eq(&Point2D::new(-4.0, 3.0))); + assert!(t.then(&r).transform_point(a).approx_eq(&r.transform_point(t.transform_point(a)))); + } + + #[test] + fn test_size_of() { + use core::mem::size_of; + assert_eq!(size_of::<default::Transform2D<f32>>(), 6*size_of::<f32>()); + assert_eq!(size_of::<default::Transform2D<f64>>(), 6*size_of::<f64>()); + } + + #[test] + pub fn test_is_identity() { + let m1 = default::Transform2D::identity(); + assert!(m1.is_identity()); + let m2 = m1.then_translate(vec2(0.1, 0.0)); + assert!(!m2.is_identity()); + } + + #[test] + pub fn test_transform_vector() { + // Translation does not apply to vectors. + let m1 = Mat::translation(1.0, 1.0); + let v1 = vec2(10.0, -10.0); + assert_eq!(v1, m1.transform_vector(v1)); + } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let m1 = Mat::rotation(rad(FRAC_PI_2)); + let mm: mint::RowMatrix3x2<_> = m1.into(); + let m2 = Mat::from(mm); + + assert_eq!(m1, m2); + } +} |