1 #[macro_use]
2 mod support;
3 
4 macro_rules! impl_mat3_tests {
5     ($t:ident, $newmat3:ident, $mat3:ident, $mat2:ident, $mat4:ident, $quat:ident, $newvec3:ident, $vec3:ident, $vec2:ident) => {
6         use core::$t::INFINITY;
7         use core::$t::NAN;
8         use core::$t::NEG_INFINITY;
9 
10         const IDENTITY: [[$t; 3]; 3] = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
11 
12         const MATRIX: [[$t; 3]; 3] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]];
13 
14         const MATRIX1D: [$t; 9] = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
15 
16         glam_test!(test_const, {
17             const M0: $mat3 = $mat3::from_cols(
18                 $newvec3(1.0, 2.0, 3.0),
19                 $newvec3(4.0, 5.0, 6.0),
20                 $newvec3(7.0, 8.0, 9.0),
21             );
22             const M1: $mat3 = $mat3::from_cols_array(&MATRIX1D);
23             const M2: $mat3 = $mat3::from_cols_array_2d(&MATRIX);
24 
25             assert_eq!(MATRIX1D, M0.to_cols_array());
26             assert_eq!(MATRIX1D, M1.to_cols_array());
27             assert_eq!(MATRIX1D, M2.to_cols_array());
28         });
29 
30         glam_test!(test_mat3_identity, {
31             assert_eq!(
32                 $mat3::IDENTITY,
33                 $mat3::from_cols_array(&[
34                     1., 0., 0., //
35                     0., 1., 0., //
36                     0., 0., 1., //
37                 ])
38             );
39             let identity = $mat3::IDENTITY;
40             assert_eq!(IDENTITY, identity.to_cols_array_2d());
41             assert_eq!($mat3::from_cols_array_2d(&IDENTITY), identity);
42             assert_eq!(identity, identity * identity);
43             assert_eq!(identity, $mat3::default());
44             assert_eq!(identity, $mat3::from_diagonal($vec3::ONE));
45         });
46 
47         glam_test!(test_mat3_zero, {
48             assert_eq!(
49                 $mat3::ZERO,
50                 $mat3::from_cols_array(&[0., 0., 0., 0., 0., 0., 0., 0., 0.])
51             );
52         });
53 
54         glam_test!(test_mat3_nan, {
55             assert!($mat3::NAN.is_nan());
56             assert!(!$mat3::NAN.is_finite());
57         });
58 
59         glam_test!(test_mat3_accessors, {
60             let mut m = $mat3::ZERO;
61             m.x_axis = $newvec3(1.0, 2.0, 3.0);
62             m.y_axis = $newvec3(4.0, 5.0, 6.0);
63             m.z_axis = $newvec3(7.0, 8.0, 9.0);
64             assert_eq!($mat3::from_cols_array_2d(&MATRIX), m);
65             assert_eq!($newvec3(1.0, 2.0, 3.0), m.x_axis);
66             assert_eq!($newvec3(4.0, 5.0, 6.0), m.y_axis);
67             assert_eq!($newvec3(7.0, 8.0, 9.0), m.z_axis);
68 
69             assert_eq!($newvec3(1.0, 2.0, 3.0), m.col(0));
70             assert_eq!($newvec3(4.0, 5.0, 6.0), m.col(1));
71             assert_eq!($newvec3(7.0, 8.0, 9.0), m.col(2));
72 
73             assert_eq!($newvec3(1.0, 4.0, 7.0), m.row(0));
74             assert_eq!($newvec3(2.0, 5.0, 8.0), m.row(1));
75             assert_eq!($newvec3(3.0, 6.0, 9.0), m.row(2));
76 
77             *m.col_mut(0) = m.col(0).zyx();
78             *m.col_mut(1) = m.col(1).zyx();
79             *m.col_mut(2) = m.col(2).zyx();
80             assert_eq!($newvec3(3.0, 2.0, 1.0), m.col(0));
81             assert_eq!($newvec3(6.0, 5.0, 4.0), m.col(1));
82             assert_eq!($newvec3(9.0, 8.0, 7.0), m.col(2));
83 
84             should_panic!({ $mat3::ZERO.col(3) });
85             should_panic!({
86                 let mut m = $mat3::ZERO;
87                 m.col_mut(3);
88             });
89             should_panic!({ $mat3::ZERO.row(3) });
90         });
91 
92         glam_test!(test_mat3_from_axes, {
93             let a = $mat3::from_cols_array_2d(&[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]);
94             assert_eq!(MATRIX, a.to_cols_array_2d());
95             let b = $mat3::from_cols(
96                 $newvec3(1.0, 2.0, 3.0),
97                 $newvec3(4.0, 5.0, 6.0),
98                 $newvec3(7.0, 8.0, 9.0),
99             );
100             assert_eq!(a, b);
101             let c = $newmat3(
102                 $newvec3(1.0, 2.0, 3.0),
103                 $newvec3(4.0, 5.0, 6.0),
104                 $newvec3(7.0, 8.0, 9.0),
105             );
106             assert_eq!(a, c);
107             let d = b.to_cols_array();
108             let f = $mat3::from_cols_array(&d);
109             assert_eq!(b, f);
110         });
111 
112         glam_test!(test_from_rotation, {
113             let rot_x1 = $mat3::from_rotation_x(deg(180.0));
114             let rot_x2 = $mat3::from_axis_angle($vec3::X, deg(180.0));
115             assert_approx_eq!(rot_x1, rot_x2);
116             let rot_x3 = $mat3::from_quat($quat::from_rotation_x(deg(180.0)));
117             assert_approx_eq!(rot_x1, rot_x3);
118 
119             let rot_y1 = $mat3::from_rotation_y(deg(180.0));
120             let rot_y2 = $mat3::from_axis_angle($vec3::Y, deg(180.0));
121             assert_approx_eq!(rot_y1, rot_y2);
122             let rot_y3 = $mat3::from_quat($quat::from_rotation_y(deg(180.0)));
123             assert_approx_eq!(rot_y1, rot_y3);
124 
125             let rot_z1 = $mat3::from_rotation_z(deg(180.0));
126             let rot_z2 = $mat3::from_axis_angle($vec3::Z, deg(180.0));
127             assert_approx_eq!(rot_z1, rot_z2);
128             let rot_z3 = $mat3::from_quat($quat::from_rotation_z(deg(180.0)));
129             assert_approx_eq!(rot_z1, rot_z3);
130 
131             should_glam_assert!({ $mat3::from_axis_angle($vec3::ZERO, 0.0) });
132             should_glam_assert!({ $mat3::from_quat($quat::from_xyzw(0.0, 0.0, 0.0, 0.0)) });
133         });
134 
135         glam_test!(test_mat3_mul, {
136             let mat_a = $mat3::from_axis_angle($vec3::Z, deg(90.0));
137             assert_approx_eq!($newvec3(-1.0, 0.0, 0.0), mat_a * $newvec3(0.0, 1.0, 0.0));
138             assert_approx_eq!(
139                 $vec3::new(-1.0, 0.0, 0.0),
140                 mat_a.mul_vec3($vec3::new(0.0, 1.0, 0.0))
141             );
142         });
143 
144         glam_test!(test_mat3_transform2d, {
145             let m = $mat3::from_translation($vec2::new(2.0, 4.0));
146             assert_eq!($vec2::ZERO, m.transform_vector2($vec2::ZERO));
147             assert_eq!($vec2::new(2.0, 4.0), m.transform_point2($vec2::ZERO));
148             assert_eq!($vec2::ZERO, m.transform_point2($vec2::new(-2.0, -4.0)));
149 
150             let m = $mat3::from_angle($t::to_radians(90.0));
151             assert_approx_eq!($vec2::Y, m.transform_vector2($vec2::X), 1e-7);
152             assert_approx_eq!($vec2::Y, m.transform_point2($vec2::X), 1e-7);
153 
154             let m = $mat3::from_scale($vec2::new(2.0, 4.0));
155             assert_eq!($vec2::new(2.0, 0.0), m.transform_vector2($vec2::X));
156             assert_eq!($vec2::new(0.0, 4.0), m.transform_vector2($vec2::Y));
157             assert_eq!($vec2::new(2.0, 0.0), m.transform_point2($vec2::X));
158             assert_eq!($vec2::new(0.0, 4.0), m.transform_point2($vec2::Y));
159 
160             should_glam_assert!({ $mat3::from_scale($vec2::ZERO) });
161 
162             let m = $mat3::from_scale_angle_translation(
163                 $vec2::new(0.5, 1.5),
164                 $t::to_radians(90.0),
165                 $vec2::new(1.0, 2.0),
166             );
167             let result2 = m.transform_vector2($vec2::Y);
168             assert_approx_eq!($vec2::new(-1.5, 0.0), result2, 1.0e-6);
169             assert_approx_eq!(result2, (m * $vec2::Y.extend(0.0)).truncate());
170 
171             let result2 = m.transform_point2($vec2::Y);
172             assert_approx_eq!($vec2::new(-0.5, 2.0), result2, 1.0e-6);
173             assert_approx_eq!(result2, (m * $vec2::Y.extend(1.0)).truncate());
174         });
175 
176         glam_test!(test_from_ypr, {
177             use glam::EulerRot;
178             let zero = deg(0.0);
179             let yaw = deg(30.0);
180             let pitch = deg(60.0);
181             let roll = deg(90.0);
182             let y0 = $mat3::from_rotation_y(yaw);
183             let y1 = $mat3::from_euler(EulerRot::YXZ, yaw, zero, zero);
184             assert_approx_eq!(y0, y1);
185 
186             let x0 = $mat3::from_rotation_x(pitch);
187             let x1 = $mat3::from_euler(EulerRot::YXZ, zero, pitch, zero);
188             assert_approx_eq!(x0, x1);
189 
190             let z0 = $mat3::from_rotation_z(roll);
191             let z1 = $mat3::from_euler(EulerRot::YXZ, zero, zero, roll);
192             assert_approx_eq!(z0, z1);
193 
194             let yx0 = y0 * x0;
195             let yx1 = $mat3::from_euler(EulerRot::YXZ, yaw, pitch, zero);
196             assert_approx_eq!(yx0, yx1, 1e-6);
197 
198             let yxz0 = y0 * x0 * z0;
199             let yxz1 = $mat3::from_euler(EulerRot::YXZ, yaw, pitch, roll);
200             assert_approx_eq!(yxz0, yxz1, 1e-6);
201         });
202 
203         glam_test!(test_from_diagonal, {
204             let m = $mat3::from_diagonal($vec3::new(2.0, 4.0, 8.0));
205             assert_approx_eq!(m * $vec3::new(1.0, 1.0, 1.0), $vec3::new(2.0, 4.0, 8.0));
206             assert_approx_eq!($newvec3(2.0, 0.0, 0.0), m.x_axis);
207             assert_approx_eq!($newvec3(0.0, 4.0, 0.0), m.y_axis);
208             assert_approx_eq!($newvec3(0.0, 0.0, 8.0), m.z_axis);
209         });
210 
211         glam_test!(test_from_mat2, {
212             let m2 = $mat2::from_cols_array_2d(&[[1.0, 2.0], [3.0, 4.0]]);
213             let m3 = $mat3::from_mat2(m2);
214             assert_eq!(
215                 $mat3::from_cols_array_2d(&[[1.0, 2.0, 0.0], [3.0, 4.0, 0.0], [0.0, 0.0, 1.0]]),
216                 m3
217             );
218         });
219 
220         glam_test!(test_from_mat4, {
221             let m4 = $mat4::from_cols_array_2d(&[
222                 [1.0, 2.0, 3.0, 4.0],
223                 [5.0, 6.0, 7.0, 8.0],
224                 [9.0, 10.0, 11.0, 12.0],
225                 [13.0, 14.0, 15.0, 16.0],
226             ]);
227             let m3 = $mat3::from_mat4(m4);
228             assert_eq!(
229                 $mat3::from_cols_array_2d(&[[1.0, 2.0, 3.0], [5.0, 6.0, 7.0], [9.0, 10.0, 11.0]]),
230                 m3
231             );
232         });
233 
234         glam_test!(test_mat3_transpose, {
235             let m = $newmat3(
236                 $newvec3(1.0, 2.0, 3.0),
237                 $newvec3(4.0, 5.0, 6.0),
238                 $newvec3(7.0, 8.0, 9.0),
239             );
240             let mt = m.transpose();
241             assert_eq!($newvec3(1.0, 4.0, 7.0), mt.x_axis);
242             assert_eq!($newvec3(2.0, 5.0, 8.0), mt.y_axis);
243             assert_eq!($newvec3(3.0, 6.0, 9.0), mt.z_axis);
244         });
245 
246         glam_test!(test_mat3_det, {
247             assert_eq!(0.0, $mat3::ZERO.determinant());
248             assert_eq!(1.0, $mat3::IDENTITY.determinant());
249             assert_eq!(1.0, $mat3::from_rotation_x(deg(90.0)).determinant());
250             assert_eq!(1.0, $mat3::from_rotation_y(deg(180.0)).determinant());
251             assert_eq!(1.0, $mat3::from_rotation_z(deg(270.0)).determinant());
252             assert_eq!(
253                 2.0 * 2.0 * 2.0,
254                 $mat3::from_diagonal($vec3::new(2.0, 2.0, 2.0)).determinant()
255             );
256         });
257 
258         glam_test!(test_mat3_inverse, {
259             // assert_eq!(None, $mat3::ZERO.inverse());
260             let inv = $mat3::IDENTITY.inverse();
261             // assert_ne!(None, inv);
262             assert_approx_eq!($mat3::IDENTITY, inv);
263 
264             let rotz = $mat3::from_rotation_z(deg(90.0));
265             let rotz_inv = rotz.inverse();
266             // assert_ne!(None, rotz_inv);
267             // let rotz_inv = rotz_inv.unwrap();
268             assert_approx_eq!($mat3::IDENTITY, rotz * rotz_inv);
269             assert_approx_eq!($mat3::IDENTITY, rotz_inv * rotz);
270 
271             let scale = $mat3::from_diagonal($vec3::new(4.0, 5.0, 6.0));
272             let scale_inv = scale.inverse();
273             // assert_ne!(None, scale_inv);
274             // let scale_inv = scale_inv.unwrap();
275             assert_approx_eq!($mat3::IDENTITY, scale * scale_inv);
276             assert_approx_eq!($mat3::IDENTITY, scale_inv * scale);
277 
278             let m = scale * rotz;
279             let m_inv = m.inverse();
280             // assert_ne!(None, m_inv);
281             // let m_inv = m_inv.unwrap();
282             assert_approx_eq!($mat3::IDENTITY, m * m_inv);
283             assert_approx_eq!($mat3::IDENTITY, m_inv * m);
284             assert_approx_eq!(m_inv, rotz_inv * scale_inv);
285 
286             should_glam_assert!({ $mat3::ZERO.inverse() });
287         });
288 
289         glam_test!(test_mat3_ops, {
290             let m0 = $mat3::from_cols_array_2d(&MATRIX);
291             let m0x2 = $mat3::from_cols_array_2d(&[
292                 [2.0, 4.0, 6.0],
293                 [8.0, 10.0, 12.0],
294                 [14.0, 16.0, 18.0],
295             ]);
296             let m0_neg = $mat3::from_cols_array_2d(&[
297                 [-1.0, -2.0, -3.0],
298                 [-4.0, -5.0, -6.0],
299                 [-7.0, -8.0, -9.0],
300             ]);
301             assert_eq!(m0x2, m0 * 2.0);
302             assert_eq!(m0x2, 2.0 * m0);
303             assert_eq!(m0x2, m0 + m0);
304             assert_eq!($mat3::ZERO, m0 - m0);
305             assert_eq!(m0_neg, -m0);
306             assert_approx_eq!(m0, m0 * $mat3::IDENTITY);
307             assert_approx_eq!(m0, $mat3::IDENTITY * m0);
308 
309             let mut m1 = m0;
310             m1 *= 2.0;
311             assert_eq!(m0x2, m1);
312 
313             let mut m1 = m0;
314             m1 += m0;
315             assert_eq!(m0x2, m1);
316 
317             let mut m1 = m0;
318             m1 -= m0;
319             assert_eq!($mat3::ZERO, m1);
320 
321             let mut m1 = $mat3::IDENTITY;
322             m1 *= m0;
323             assert_approx_eq!(m0, m1);
324         });
325 
326         glam_test!(test_mat3_fmt, {
327             let a = $mat3::from_cols_array_2d(&MATRIX);
328             assert_eq!(format!("{}", a), "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]");
329         });
330 
331         glam_test!(test_mat3_to_from_slice, {
332             let m = $mat3::from_cols_slice(&MATRIX1D);
333             assert_eq!($mat3::from_cols_array(&MATRIX1D), m);
334             let mut out: [$t; 9] = Default::default();
335             m.write_cols_to_slice(&mut out);
336             assert_eq!(MATRIX1D, out);
337 
338             should_panic!({ $mat3::from_cols_slice(&[0.0; 8]) });
339             should_panic!({ $mat3::IDENTITY.write_cols_to_slice(&mut [0.0; 8]) });
340         });
341 
342         glam_test!(test_sum, {
343             let id = $mat3::IDENTITY;
344             assert_eq!([id, id].iter().sum::<$mat3>(), id + id);
345             assert_eq!([id, id].into_iter().sum::<$mat3>(), id + id);
346         });
347 
348         glam_test!(test_product, {
349             let two = $mat3::IDENTITY + $mat3::IDENTITY;
350             assert_eq!([two, two].iter().product::<$mat3>(), two * two);
351             assert_eq!([two, two].into_iter().product::<$mat3>(), two * two);
352         });
353 
354         glam_test!(test_mat3_is_finite, {
355             assert!($mat3::IDENTITY.is_finite());
356             assert!(!($mat3::IDENTITY * INFINITY).is_finite());
357             assert!(!($mat3::IDENTITY * NEG_INFINITY).is_finite());
358             assert!(!($mat3::IDENTITY * NAN).is_finite());
359         });
360     };
361 }
362 
363 macro_rules! impl_as_ref_tests {
364     ($mat:ident) => {
365         glam_test!(test_as_ref, {
366             let m = $mat::from_cols_array_2d(&MATRIX);
367             assert_eq!(MATRIX1D, *m.as_ref());
368         });
369         glam_test!(test_as_mut, {
370             let mut m = $mat::ZERO;
371             *m.as_mut() = MATRIX1D;
372             assert_eq!($mat::from_cols_array_2d(&MATRIX), m);
373         });
374     };
375 }
376 
377 mod mat3 {
378     use super::support::deg;
379     use glam::{mat3, swizzles::*, vec3, vec3a, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A};
380 
381     glam_test!(test_align, {
382         use std::mem;
383         assert_eq!(36, mem::size_of::<Mat3>());
384         assert_eq!(mem::align_of::<Vec3>(), mem::align_of::<Mat3>());
385     });
386 
387     glam_test!(test_mul_vec3a, {
388         let mat_a = Mat3::from_axis_angle(Vec3::Z, deg(90.0));
389         assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a * Vec3A::Y);
390         assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a.mul_vec3a(Vec3A::Y));
391     });
392 
393     glam_test!(test_as, {
394         use glam::DMat3;
395         assert_eq!(
396             DMat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
397             Mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]).as_dmat3()
398         );
399         assert_eq!(
400             Mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
401             DMat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]).as_mat3()
402         );
403     });
404 
405     impl_mat3_tests!(f32, mat3, Mat3, Mat2, Mat4, Quat, vec3, Vec3, Vec2);
406     impl_as_ref_tests!(Mat3);
407 }
408 
409 mod mat3a {
410     use super::support::deg;
411     use glam::{mat3a, swizzles::*, vec3a, Mat2, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A};
412 
413     glam_test!(test_align, {
414         use std::mem;
415         assert_eq!(48, mem::size_of::<Mat3A>());
416         assert_eq!(mem::align_of::<Vec3A>(), mem::align_of::<Mat3A>());
417     });
418 
419     glam_test!(test_mul_vec3a, {
420         let mat_a = Mat3A::from_axis_angle(Vec3::Z, deg(90.0));
421         assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a * Vec3A::Y);
422         assert_approx_eq!(vec3a(-1.0, 0.0, 0.0), mat_a.mul_vec3a(Vec3A::Y));
423     });
424 
425     glam_test!(test_as, {
426         use glam::DMat3;
427         assert_eq!(
428             DMat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]),
429             Mat3A::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]).as_dmat3()
430         );
431     });
432 
433     impl_mat3_tests!(f32, mat3a, Mat3A, Mat2, Mat4, Quat, vec3a, Vec3, Vec2);
434 }
435 
436 mod dmat3 {
437     use super::support::deg;
438     use glam::{dmat3, dvec3, swizzles::*, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3};
439 
440     glam_test!(test_align, {
441         use std::mem;
442         assert_eq!(72, mem::size_of::<DMat3>());
443         assert_eq!(mem::align_of::<DVec3>(), mem::align_of::<DMat3>());
444     });
445 
446     impl_mat3_tests!(f64, dmat3, DMat3, DMat2, DMat4, DQuat, dvec3, DVec3, DVec2);
447     impl_as_ref_tests!(DMat3);
448 }
449