| #[macro_use] |
| mod support; |
| |
| macro_rules! impl_mat2_tests { |
| ($t:ident, $newmat2:ident, $mat2:ident, $mat3:ident, $newvec2:ident, $vec2:ident) => { |
| const IDENTITY: [[$t; 2]; 2] = [[1.0, 0.0], [0.0, 1.0]]; |
| |
| const MATRIX: [[$t; 2]; 2] = [[1.0, 2.0], [3.0, 4.0]]; |
| |
| const MATRIX1D: [$t; 4] = [1.0, 2.0, 3.0, 4.0]; |
| |
| glam_test!(test_const, { |
| const M0: $mat2 = $mat2::from_cols($newvec2(1.0, 2.0), $newvec2(3.0, 4.0)); |
| const M1: $mat2 = $mat2::from_cols_array(&MATRIX1D); |
| const M2: $mat2 = $mat2::from_cols_array_2d(&MATRIX); |
| |
| assert_eq!(MATRIX1D, M0.to_cols_array()); |
| assert_eq!(MATRIX1D, M1.to_cols_array()); |
| assert_eq!(MATRIX1D, M2.to_cols_array()); |
| }); |
| |
| glam_test!(test_mat2_identity, { |
| assert_eq!($mat2::IDENTITY, $mat2::from_cols_array(&[1., 0., 0., 1.])); |
| let identity = $mat2::IDENTITY; |
| assert_eq!(IDENTITY, identity.to_cols_array_2d()); |
| assert_eq!($mat2::from_cols_array_2d(&IDENTITY), identity); |
| assert_eq!(identity, identity * identity); |
| assert_eq!(identity, $mat2::default()); |
| assert_eq!(identity, $mat2::from_diagonal($vec2::ONE)); |
| }); |
| |
| glam_test!(test_mat2_zero, { |
| assert_eq!($mat2::ZERO, $mat2::from_cols_array(&[0., 0., 0., 0.])); |
| }); |
| |
| glam_test!(test_mat2_nan, { |
| assert!($mat2::NAN.is_nan()); |
| assert!(!$mat2::NAN.is_finite()); |
| }); |
| |
| glam_test!(test_mat2_accessors, { |
| let mut m = $mat2::ZERO; |
| m.x_axis = $vec2::new(1.0, 2.0); |
| m.y_axis = $vec2::new(3.0, 4.0); |
| assert_eq!($mat2::from_cols_array_2d(&MATRIX), m); |
| assert_eq!($vec2::new(1.0, 2.0), m.x_axis); |
| assert_eq!($vec2::new(3.0, 4.0), m.y_axis); |
| |
| assert_eq!($vec2::new(1.0, 2.0), m.col(0)); |
| assert_eq!($vec2::new(3.0, 4.0), m.col(1)); |
| |
| assert_eq!($newvec2(1.0, 3.0), m.row(0)); |
| assert_eq!($newvec2(2.0, 4.0), m.row(1)); |
| |
| *m.col_mut(0) = m.col(0).yx(); |
| *m.col_mut(1) = m.col(1).yx(); |
| assert_eq!($vec2::new(2.0, 1.0), m.col(0)); |
| assert_eq!($vec2::new(4.0, 3.0), m.col(1)); |
| |
| should_panic!({ $mat2::ZERO.col(2) }); |
| should_panic!({ |
| let mut m = $mat2::ZERO; |
| m.col_mut(2); |
| }); |
| should_panic!({ $mat2::ZERO.row(2) }); |
| }); |
| |
| glam_test!(test_mat2_from_axes, { |
| let a = $mat2::from_cols_array_2d(&[[1.0, 2.0], [3.0, 4.0]]); |
| assert_eq!(MATRIX, a.to_cols_array_2d()); |
| let b = $mat2::from_cols($newvec2(1.0, 2.0), $newvec2(3.0, 4.0)); |
| assert_eq!(a, b); |
| let c = $newmat2($newvec2(1.0, 2.0), $newvec2(3.0, 4.0)); |
| assert_eq!(a, c); |
| let d = b.to_cols_array(); |
| let f = $mat2::from_cols_array(&d); |
| assert_eq!(b, f); |
| }); |
| |
| glam_test!(test_mat2_mul, { |
| let mat_a = $mat2::from_angle(deg(90.0)); |
| let res_a = mat_a * $vec2::Y; |
| assert_approx_eq!($newvec2(-1.0, 0.0), res_a); |
| let res_b = mat_a * $vec2::X; |
| assert_approx_eq!($newvec2(0.0, 1.0), res_b); |
| }); |
| |
| glam_test!(test_from_scale_angle, { |
| let rot = $mat2::from_scale_angle($vec2::new(4.0, 2.0), deg(180.0)); |
| assert_approx_eq!($vec2::X * -4.0, rot * $vec2::X, 1.0e-6); |
| assert_approx_eq!($vec2::Y * -2.0, rot * $vec2::Y, 1.0e-6); |
| }); |
| |
| glam_test!(test_from_diagonal, { |
| let m = $mat2::from_diagonal($vec2::new(2 as $t, 4 as $t)); |
| assert_eq!( |
| $mat2::from_cols_array_2d(&[[2 as $t, 0 as $t], [0 as $t, 4 as $t]]), |
| m |
| ); |
| assert_approx_eq!(m * $vec2::new(1.0, 1.0), $vec2::new(2.0, 4.0)); |
| assert_approx_eq!($vec2::X * 2.0, m.x_axis); |
| assert_approx_eq!($vec2::Y * 4.0, m.y_axis); |
| }); |
| |
| glam_test!(test_from_mat3, { |
| let m3 = |
| $mat3::from_cols_array_2d(&[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]); |
| let m2 = $mat2::from_mat3(m3); |
| assert_eq!($mat2::from_cols_array_2d(&[[1.0, 2.0], [4.0, 5.0]]), m2); |
| }); |
| |
| glam_test!(test_mat2_transpose, { |
| let m = $newmat2($newvec2(1.0, 2.0), $newvec2(3.0, 4.0)); |
| let mt = m.transpose(); |
| assert_eq!($newvec2(1.0, 3.0), mt.x_axis); |
| assert_eq!($newvec2(2.0, 4.0), mt.y_axis); |
| }); |
| |
| glam_test!(test_mat2_det, { |
| assert_eq!(0.0, $mat2::ZERO.determinant()); |
| assert_eq!(1.0, $mat2::IDENTITY.determinant()); |
| assert_eq!(1.0, $mat2::from_angle(deg(90.0)).determinant()); |
| assert_eq!(1.0, $mat2::from_angle(deg(180.0)).determinant()); |
| assert_eq!(1.0, $mat2::from_angle(deg(270.0)).determinant()); |
| assert_eq!( |
| 2.0 * 2.0, |
| $mat2::from_diagonal($newvec2(2.0, 2.0)).determinant() |
| ); |
| assert_eq!( |
| 1.0 * 4.0 - 2.0 * 3.0, |
| $mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]).determinant() |
| ); |
| }); |
| |
| glam_test!(test_mat2_inverse, { |
| let inv = $mat2::IDENTITY.inverse(); |
| assert_approx_eq!($mat2::IDENTITY, inv); |
| |
| let rot = $mat2::from_angle(deg(90.0)); |
| let rot_inv = rot.inverse(); |
| assert_approx_eq!($mat2::IDENTITY, rot * rot_inv); |
| assert_approx_eq!($mat2::IDENTITY, rot_inv * rot); |
| |
| let scale = $mat2::from_diagonal($newvec2(4.0, 5.0)); |
| let scale_inv = scale.inverse(); |
| assert_approx_eq!($mat2::IDENTITY, scale * scale_inv); |
| assert_approx_eq!($mat2::IDENTITY, scale_inv * scale); |
| |
| let m = scale * rot; |
| let m_inv = m.inverse(); |
| assert_approx_eq!($mat2::IDENTITY, m * m_inv); |
| assert_approx_eq!($mat2::IDENTITY, m_inv * m); |
| assert_approx_eq!(m_inv, rot_inv * scale_inv); |
| |
| should_glam_assert!({ $mat2::ZERO.inverse() }); |
| }); |
| |
| glam_test!(test_mat2_ops, { |
| let m0 = $mat2::from_cols_array_2d(&MATRIX); |
| let m0x2 = $mat2::from_cols_array_2d(&[[2.0, 4.0], [6.0, 8.0]]); |
| let m0_neg = $mat2::from_cols_array_2d(&[[-1.0, -2.0], [-3.0, -4.0]]); |
| assert_eq!(m0x2, m0 * 2.0); |
| assert_eq!(m0x2, 2.0 * m0); |
| assert_eq!(m0x2, m0 + m0); |
| assert_eq!($mat2::ZERO, m0 - m0); |
| assert_eq!(m0_neg, -m0); |
| assert_approx_eq!(m0, m0 * $mat2::IDENTITY); |
| assert_approx_eq!(m0, $mat2::IDENTITY * m0); |
| |
| let mut m1 = m0; |
| m1 *= 2.0; |
| assert_eq!(m0x2, m1); |
| |
| let mut m1 = m0; |
| m1 += m0; |
| assert_eq!(m0x2, m1); |
| |
| let mut m1 = m0; |
| m1 -= m0; |
| assert_eq!($mat2::ZERO, m1); |
| |
| let mut m1 = $mat2::IDENTITY; |
| m1 *= m0; |
| assert_approx_eq!(m0, m1); |
| }); |
| |
| glam_test!(test_mat2_fmt, { |
| let a = $mat2::from_cols_array_2d(&MATRIX); |
| assert_eq!(format!("{}", a), "[[1, 2], [3, 4]]"); |
| }); |
| |
| glam_test!(test_mat2_to_from_slice, { |
| let m = $mat2::from_cols_slice(&MATRIX1D); |
| assert_eq!($mat2::from_cols_array(&MATRIX1D), m); |
| let mut out: [$t; 4] = Default::default(); |
| m.write_cols_to_slice(&mut out); |
| assert_eq!(MATRIX1D, out); |
| |
| should_panic!({ $mat2::from_cols_slice(&[0.0; 3]) }); |
| should_panic!({ $mat2::IDENTITY.write_cols_to_slice(&mut [0.0; 3]) }); |
| }); |
| |
| glam_test!(test_sum, { |
| let id = $mat2::IDENTITY; |
| assert_eq!([id, id].iter().sum::<$mat2>(), id + id); |
| assert_eq!([id, id].into_iter().sum::<$mat2>(), id + id); |
| }); |
| |
| glam_test!(test_product, { |
| let two = $mat2::IDENTITY + $mat2::IDENTITY; |
| assert_eq!([two, two].iter().product::<$mat2>(), two * two); |
| assert_eq!([two, two].into_iter().product::<$mat2>(), two * two); |
| }); |
| |
| glam_test!(test_mat2_is_finite, { |
| use std::$t::INFINITY; |
| use std::$t::NAN; |
| use std::$t::NEG_INFINITY; |
| assert!($mat2::IDENTITY.is_finite()); |
| assert!(!($mat2::IDENTITY * INFINITY).is_finite()); |
| assert!(!($mat2::IDENTITY * NEG_INFINITY).is_finite()); |
| assert!(!($mat2::IDENTITY * NAN).is_finite()); |
| }); |
| }; |
| } |
| |
| macro_rules! impl_as_ref_tests { |
| ($mat:ident) => { |
| glam_test!(test_as_ref, { |
| let m = $mat::from_cols_array_2d(&MATRIX); |
| assert_eq!(MATRIX1D, *m.as_ref()); |
| }); |
| glam_test!(test_as_mut, { |
| let mut m = $mat::ZERO; |
| *m.as_mut() = MATRIX1D; |
| assert_eq!($mat::from_cols_array_2d(&MATRIX), m); |
| }); |
| }; |
| } |
| |
| mod mat2 { |
| use super::support::deg; |
| use glam::{mat2, swizzles::*, vec2, Mat2, Mat3, Vec2}; |
| |
| glam_test!(test_align, { |
| use std::mem; |
| assert_eq!(16, mem::size_of::<Mat2>()); |
| if cfg!(feature = "scalar-math") { |
| assert_eq!(mem::align_of::<Vec2>(), mem::align_of::<Mat2>()); |
| } else { |
| assert_eq!(16, mem::align_of::<Mat2>()); |
| } |
| }); |
| |
| glam_test!(test_from_mat3a, { |
| use glam::Mat3A; |
| let m3 = Mat3A::from_cols_array_2d(&[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]); |
| let m2 = Mat2::from_mat3a(m3); |
| assert_eq!(Mat2::from_cols_array_2d(&[[1.0, 2.0], [4.0, 5.0]]), m2); |
| }); |
| |
| glam_test!(test_as, { |
| use glam::DMat2; |
| assert_eq!( |
| DMat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]), |
| Mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]).as_dmat2() |
| ); |
| assert_eq!( |
| Mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]), |
| DMat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]).as_mat2() |
| ); |
| }); |
| |
| impl_mat2_tests!(f32, mat2, Mat2, Mat3, vec2, Vec2); |
| impl_as_ref_tests!(Mat2); |
| } |
| |
| mod dmat2 { |
| use super::support::deg; |
| use glam::{dmat2, dvec2, swizzles::*, DMat2, DMat3, DVec2}; |
| |
| glam_test!(test_align, { |
| use std::mem; |
| assert_eq!(32, mem::size_of::<DMat2>()); |
| assert_eq!(mem::align_of::<DVec2>(), mem::align_of::<DMat2>()); |
| }); |
| |
| impl_mat2_tests!(f64, dmat2, DMat2, DMat3, dvec2, DVec2); |
| impl_as_ref_tests!(DMat2); |
| } |