Skip to main content

math/
lib.rs

1pub mod cube;
2pub mod plane;
3pub mod ray;
4pub mod sphere;
5
6pub mod collision;
7
8pub use maths_rs::cross;
9pub use maths_rs::dot;
10pub use maths_rs::length;
11pub use maths_rs::mag as magnitude;
12pub use maths_rs::mag2 as magnitude_squared;
13pub use maths_rs::mat;
14pub use maths_rs::normalize;
15pub use maths_rs::num::Base;
16pub use maths_rs::num::Number;
17pub use maths_rs::vec::Magnitude;
18pub use maths_rs::vec::VecN;
19pub use maths_rs::Mat3f as Matrix3;
20pub use maths_rs::Mat4f as Matrix4;
21pub use maths_rs::Quatf as Quaternion;
22pub use maths_rs::Vec2f as Vector2;
23pub use maths_rs::Vec3f as Vector3;
24pub use maths_rs::Vec4f as Vector4;
25
26#[macro_use]
27pub mod macros {
28	#[macro_export]
29	macro_rules! assert_float_eq_with_epsilon {
30		($left:expr, $right:expr, $epsilon:expr) => {
31			match (&$left, &$right) {
32				(left_val, right_val) => {
33					if ((*left_val as f64) - (*right_val as f64)).abs() > $epsilon as f64 {
34						panic!(
35							"assertion failed: `(left == right)`\n  left: `{:?}`,\n right: `{:?}`",
36							*left_val, *right_val
37						)
38					}
39				}
40			}
41		};
42		($left:expr, $right:expr, $epsilon:expr, $($arg:tt)+) => {
43			match (&$left, &$right) {
44				(left_val, right_val) => {
45					if ((*left_val as f64) - (*right_val as f64)).abs() > $epsilon as f64 {
46						panic!(
47							"assertion failed: `(left == right)`\n  left: `{:?}`,\n right: `{:?}`\n{}",
48							*left_val, *right_val, format_args!($($arg)+)
49						)
50					}
51				}
52			}
53		};
54	}
55
56	#[macro_export]
57	macro_rules! assert_float_eq {
58		($left:expr, $right:expr) => {
59			$crate::assert_float_eq_with_epsilon!($left, $right, 0.001)
60		};
61		($left:expr, $right:expr, $($arg:tt)+) => {
62			$crate::assert_float_eq_with_epsilon!($left, $right, 0.001, $($arg)+)
63		};
64	}
65
66	#[macro_export]
67	macro_rules! assert_vec3f_near {
68		($left:expr, $right:expr) => {
69			$crate::assert_float_eq!($left.x, $right.x);
70			$crate::assert_float_eq!($left.y, $right.y);
71			$crate::assert_float_eq!($left.z, $right.z);
72		};
73		($left:expr, $right:expr, $($arg:tt)+) => {
74			$crate::assert_float_eq!($left.x, $right.x, $($arg)+);
75			$crate::assert_float_eq!($left.y, $right.y, $($arg)+);
76			$crate::assert_float_eq!($left.z, $right.z, $($arg)+);
77		};
78	}
79}
80
81use maths_rs::mat::{MatNew4, MatTranspose as _};
82
83/// The `ShaderMatrix4` struct provides the 4-by-4 matrix layout that graphics backends expect from CPU data.
84#[repr(C, align(16))]
85#[derive(Clone, Copy, Debug, Default, PartialEq)]
86pub struct ShaderMatrix4(pub [f32; 16]);
87
88/// The `ShaderMatrix4x3` struct provides the compact affine matrix layout used to send model transforms to the GPU.
89#[repr(C, align(16))]
90#[derive(Clone, Copy, Debug, Default, PartialEq)]
91#[cfg(target_os = "macos")]
92pub struct ShaderMatrix4x3(pub [f32; 16]);
93
94/// The `ShaderMatrix4x3` struct provides the compact affine matrix layout used to send model transforms to the GPU.
95#[repr(C, align(16))]
96#[derive(Clone, Copy, Debug, Default, PartialEq)]
97#[cfg(not(target_os = "macos"))]
98pub struct ShaderMatrix4x3(pub [f32; 12]);
99
100impl From<Matrix4> for ShaderMatrix4 {
101	fn from(mut value: Matrix4) -> Self {
102		#[cfg(target_os = "macos")]
103		{
104			value = value.transpose();
105		}
106
107		Self([
108			value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8], value[9], value[10],
109			value[11], value[12], value[13], value[14], value[15],
110		])
111	}
112}
113
114impl From<Matrix4> for ShaderMatrix4x3 {
115	fn from(mut value: Matrix4) -> Self {
116		value = value.transpose();
117		let value = [
118			value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8], value[9], value[10],
119			value[11], value[12], value[13], value[14], value[15],
120		];
121
122		#[cfg(target_os = "macos")]
123		return Self([
124			value[0], value[1], value[2], 0.0, value[4], value[5], value[6], 0.0, value[8], value[9], value[10], 0.0,
125			value[12], value[13], value[14], 0.0,
126		]);
127
128		#[cfg(not(target_os = "macos"))]
129		Self([
130			value[0], value[1], value[2], value[4], value[5], value[6], value[8], value[9], value[10], value[12], value[13],
131			value[14],
132		])
133	}
134}
135
136/// Converts a camera-relative movement command to a direction on the horizontal plane.
137pub fn plane_navigation(direction: Vector3, command: Vector3) -> Vector3 {
138	Vector3::new(direction.x, 0.0, direction.z) * command.z + Vector3::new(direction.z, 0.0, -direction.x) * command.x
139}
140
141/// Returns a left-handed perspective projection matrix with a depth range from 0 to 1.
142///
143/// # Arguments
144///
145/// * `fov` - The full vertical field of view, in degrees.
146/// * `aspect_ratio` - The width-to-height ratio of the viewport.
147/// * `near_plane` - The distance to the near clipping plane.
148/// * `far_plane` - The distance to the far clipping plane.
149pub fn projection_matrix(fov: f32, aspect_ratio: f32, near_plane: f32, far_plane: f32) -> maths_rs::Mat4f {
150	let h = 1f32 / (fov / 2f32).to_radians().tan();
151	let w = h / aspect_ratio;
152
153	let far_minus_near = far_plane - near_plane;
154
155	let a = -near_plane / far_minus_near;
156	let b = (near_plane * far_plane) / far_minus_near;
157
158	maths_rs::Mat4f::from((
159		maths_rs::Vec4f::from((w, 0f32, 0f32, 0f32)),
160		maths_rs::Vec4f::from((0f32, h, 0f32, 0f32)),
161		maths_rs::Vec4f::from((0f32, 0f32, a, b)),
162		maths_rs::Vec4f::from((0f32, 0f32, 1f32, 0f32)),
163	))
164}
165
166pub fn orthographic_matrix_centered(width: f32, height: f32, near_plane: f32, far_plane: f32) -> maths_rs::Mat4f {
167	let far_minus_near = far_plane - near_plane;
168	maths_rs::Mat4f::from((
169		maths_rs::Vec4f::from((2f32 / width, 0f32, 0f32, 0f32)),
170		maths_rs::Vec4f::from((0f32, 2f32 / height, 0f32, 0f32)),
171		maths_rs::Vec4f::from((0f32, 0f32, -1f32 / far_minus_near, far_plane / far_minus_near)),
172		maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
173	))
174}
175
176pub fn orthographic_matrix(left: f32, right: f32, bottom: f32, top: f32, near_plane: f32, far_plane: f32) -> maths_rs::Mat4f {
177	let far_minus_near = far_plane - near_plane;
178	maths_rs::Mat4f::from((
179		maths_rs::Vec4f::from((2f32 / (right - left), 0f32, 0f32, -(right + left) / (right - left))),
180		maths_rs::Vec4f::from((0f32, 2f32 / (top - bottom), 0f32, -(top + bottom) / (top - bottom))),
181		maths_rs::Vec4f::from((0f32, 0f32, -1f32 / far_minus_near, far_plane / far_minus_near)),
182		maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
183	))
184}
185
186pub fn are_colinear(a: crate::Vector3, b: crate::Vector3) -> bool {
187	maths_rs::dot(a, b).abs() > 0.99f32
188}
189
190pub fn from_normal(normal: Vector3) -> maths_rs::Mat4f {
191	let x_basis;
192	let y_basis;
193	let z_basis = normal;
194
195	if are_colinear(normal, Vector3::new(0f32, 1f32, 0f32)) {
196		x_basis = maths_rs::normalize(maths_rs::cross(
197			maths_rs::normalize(normal),
198			crate::Vector3::new(0f32, 0f32, 1f32),
199		));
200		y_basis = maths_rs::normalize(maths_rs::cross(maths_rs::normalize(normal), x_basis));
201	} else {
202		x_basis = maths_rs::normalize(maths_rs::cross(Vector3::new(0f32, 1f32, 0f32), maths_rs::normalize(normal)));
203		y_basis = maths_rs::normalize(maths_rs::cross(maths_rs::normalize(normal), x_basis));
204	}
205
206	maths_rs::Mat4f::from((
207		maths_rs::Vec4f::from((x_basis, 0f32)),
208		maths_rs::Vec4f::from((y_basis, 0f32)),
209		maths_rs::Vec4f::from((z_basis, 0f32)),
210		maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
211	))
212}
213
214pub use from_normal as look_down;
215
216pub fn from_rotation(axis: Vector3, theta: f32) -> maths_rs::Mat4f {
217	let c = theta.cos();
218	let s = -theta.sin();
219	let one_minus_c = 1.0 - c;
220	let x = axis.x;
221	let y = axis.y;
222	let z = axis.z;
223
224	maths_rs::Mat4f::new(
225		c + x * x * one_minus_c,
226		x * y * one_minus_c - z * s,
227		x * z * one_minus_c + y * s,
228		0.0,
229		y * x * one_minus_c + z * s,
230		c + y * y * one_minus_c,
231		y * z * one_minus_c - x * s,
232		0.0,
233		z * x * one_minus_c - y * s,
234		z * y * one_minus_c + x * s,
235		c + z * z * one_minus_c,
236		0.0,
237		0.0,
238		0.0,
239		0.0,
240		1.0,
241	)
242}
243
244pub fn orientation_from_direction(direction: Vector3) -> Quaternion {
245	// normalize input direction
246	let dir = normalize(direction);
247
248	// base forward vector (+Z)
249	let forward = Vector3::new(0.0, 0.0, 1.0);
250
251	// handle parallel and anti-parallel cases
252	let dot = dot(forward, dir);
253	if dot > 0.9999 {
254		return Quaternion::identity();
255	} else if dot < -0.9999 {
256		// rotate 180 degrees around any perpendicular axis (X is fine if not parallel)
257		return Quaternion::from_axis_angle(Vector3::new(1.0, 0.0, 0.0), std::f32::consts::PI);
258	}
259
260	// rotation axis is perpendicular to both vectors
261	let axis = normalize(cross(forward, dir));
262
263	// rotation angle is arccos of the dot product
264	let angle = dot.acos();
265
266	Quaternion::from_axis_angle(axis, angle)
267}
268
269pub fn direction_from_orientation(orientation: Quaternion) -> Vector3 {
270	// Rotate the base forward vector (0, 0, 1) by the quaternion
271	let forward = Vector3::new(0.0, 0.0, 1.0);
272	let rotated_forward = orientation * forward;
273	normalize(rotated_forward)
274}
275
276/// Returns the inverse of a left-handed, row-major 4-by-4 matrix.
277pub fn inverse(m: maths_rs::Mat4f) -> maths_rs::Mat4f {
278	let mut inv = maths_rs::Mat4f::default();
279
280	inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] + m[9] * m[7] * m[14] + m[13] * m[6] * m[11]
281		- m[13] * m[7] * m[10];
282	inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11]
283		+ m[12] * m[7] * m[10];
284	inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] + m[8] * m[7] * m[13] + m[12] * m[5] * m[11]
285		- m[12] * m[7] * m[9];
286	inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10]
287		+ m[12] * m[6] * m[9];
288	inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11]
289		+ m[13] * m[3] * m[10];
290	inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] + m[8] * m[3] * m[14] + m[12] * m[2] * m[11]
291		- m[12] * m[3] * m[10];
292	inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] - m[8] * m[3] * m[13] - m[12] * m[1] * m[11]
293		+ m[12] * m[3] * m[9];
294	inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] + m[8] * m[2] * m[13] + m[12] * m[1] * m[10]
295		- m[12] * m[2] * m[9];
296	inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] + m[5] * m[3] * m[14] + m[13] * m[2] * m[7]
297		- m[13] * m[3] * m[6];
298	inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] - m[4] * m[3] * m[14] - m[12] * m[2] * m[7]
299		+ m[12] * m[3] * m[6];
300	inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] + m[4] * m[3] * m[13] + m[12] * m[1] * m[7]
301		- m[12] * m[3] * m[5];
302	inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] - m[4] * m[2] * m[13] - m[12] * m[1] * m[6]
303		+ m[12] * m[2] * m[5];
304	inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] - m[5] * m[3] * m[10] - m[9] * m[2] * m[7]
305		+ m[9] * m[3] * m[6];
306	inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] + m[4] * m[3] * m[10] + m[8] * m[2] * m[7]
307		- m[8] * m[3] * m[6];
308	inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] - m[4] * m[3] * m[9] - m[8] * m[1] * m[7]
309		+ m[8] * m[3] * m[5];
310	inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] + m[4] * m[2] * m[9] + m[8] * m[1] * m[6]
311		- m[8] * m[2] * m[5];
312
313	let det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
314
315	if det == 0f32 {
316		panic!("Matrix is not invertible");
317	}
318
319	let det = 1.0 / det;
320
321	for i in 0..16 {
322		inv[i] *= det;
323	}
324
325	inv
326}
327
328#[cfg(test)]
329mod tests {
330	use maths_rs::Vec3f;
331
332	#[test]
333	fn test_float_equality() {
334		let result = 2.0 + 2.0;
335		assert_float_eq!(result, 4.0);
336	}
337
338	#[test]
339	#[should_panic(expected = "assertion failed")]
340	fn test_float_inequality() {
341		let result = 2.0 + 2.0;
342		assert_float_eq!(result, 5.0);
343	}
344
345	#[test]
346	fn test_vec3f_near() {
347		let vec1 = Vec3f::new(1.0, 2.0, 3.0);
348		let vec2 = Vec3f::new(1.0, 2.0, 3.00005);
349		assert_vec3f_near!(vec1, vec2);
350	}
351
352	use maths_rs::mat::{MatInverse, MatNew4};
353
354	use crate::orientation_from_direction;
355
356	#[test]
357	fn test_from_normal() {
358		let value = super::from_normal(crate::Vector3::new(0f32, 0f32, 1f32));
359		assert_eq!(
360			value,
361			maths_rs::Mat4f::from((
362				maths_rs::Vec4f::from((1f32, 0f32, 0f32, 0f32)),
363				maths_rs::Vec4f::from((0f32, 1f32, 0f32, 0f32)),
364				maths_rs::Vec4f::from((0f32, 0f32, 1f32, 0f32)),
365				maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
366			))
367		);
368
369		let value = super::from_normal(crate::Vector3::new(0f32, 1f32, 0f32));
370		assert_eq!(
371			value,
372			maths_rs::Mat4f::from((
373				maths_rs::Vec4f::from((1f32, 0f32, 0f32, 0f32)),
374				maths_rs::Vec4f::from((0f32, 0f32, -1f32, 0f32)),
375				maths_rs::Vec4f::from((0f32, 1f32, 0f32, 0f32)),
376				maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
377			))
378		);
379
380		let value = super::from_normal(crate::Vector3::new(1f32, 0f32, 0f32));
381		assert_eq!(
382			value,
383			maths_rs::Mat4f::from((
384				maths_rs::Vec4f::from((0f32, 0f32, -1f32, 0f32)),
385				maths_rs::Vec4f::from((0f32, 1f32, 0f32, 0f32)),
386				maths_rs::Vec4f::from((1f32, 0f32, 0f32, 0f32)),
387				maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
388			))
389		);
390
391		let value = super::from_normal(crate::Vector3::new(-1f32, 0f32, 0f32));
392		assert_eq!(
393			value,
394			maths_rs::Mat4f::from((
395				maths_rs::Vec4f::from((0f32, 0f32, 1f32, 0f32)),
396				maths_rs::Vec4f::from((0f32, 1f32, 0f32, 0f32)),
397				maths_rs::Vec4f::from((-1f32, 0f32, 0f32, 0f32)),
398				maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
399			))
400		);
401	}
402
403	#[test]
404	fn test_from_normal_preserves_handedness_for_vertical_vectors() {
405		for normal in [crate::Vector3::new(0.0, 1.0, 0.0), crate::Vector3::new(0.0, -1.0, 0.0)] {
406			let basis = super::from_normal(normal);
407			let x = crate::Vector3::new(basis[0], basis[1], basis[2]);
408			let y = crate::Vector3::new(basis[4], basis[5], basis[6]);
409			let z = crate::Vector3::new(basis[8], basis[9], basis[10]);
410
411			assert!(maths_rs::dot(maths_rs::cross(x, y), z) > 0.0);
412		}
413	}
414
415	#[test]
416	fn test_inverse_matrix() {
417		let value = maths_rs::Mat4f::from((
418			maths_rs::Vec4f::from((1f32, 0f32, 0f32, 0f32)),
419			maths_rs::Vec4f::from((0f32, 1f32, 0f32, 0f32)),
420			maths_rs::Vec4f::from((0f32, 0f32, 1f32, 0f32)),
421			maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
422		));
423		let value = super::inverse(value);
424		assert_eq!(
425			value,
426			maths_rs::Mat4f::from((
427				maths_rs::Vec4f::from((1f32, 0f32, 0f32, 0f32)),
428				maths_rs::Vec4f::from((0f32, 1f32, 0f32, 0f32)),
429				maths_rs::Vec4f::from((0f32, 0f32, 1f32, 0f32)),
430				maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
431			))
432		);
433
434		let value = maths_rs::Mat4f::from((
435			maths_rs::Vec4f::from((1f32, 0f32, 0f32, 0f32)),
436			maths_rs::Vec4f::from((0f32, 2f32, 0f32, 0f32)),
437			maths_rs::Vec4f::from((0f32, 0f32, 3f32, 0f32)),
438			maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
439		));
440		let value = super::inverse(value);
441		assert_eq!(
442			value,
443			maths_rs::Mat4f::from((
444				maths_rs::Vec4f::from((1f32, 0f32, 0f32, 0f32)),
445				maths_rs::Vec4f::from((0f32, 0.5f32, 0f32, 0f32)),
446				maths_rs::Vec4f::from((0f32, 0f32, 1f32 / 3f32, 0f32)),
447				maths_rs::Vec4f::from((0f32, 0f32, 0f32, 1f32)),
448			))
449		);
450
451		let nearly_equal = |a: f32, b: f32| (a - b).abs() < 0.0001f32;
452
453		let value = maths_rs::Mat4f::from((
454			maths_rs::Vec4f::from((1f32, 2f32, 3f32, 4f32)),
455			maths_rs::Vec4f::from((5f32, 1f32, 6f32, 7f32)),
456			maths_rs::Vec4f::from((8f32, 9f32, 1f32, 10f32)),
457			maths_rs::Vec4f::from((11f32, 12f32, 13f32, 1f32)),
458		));
459		let value = value.inverse();
460
461		assert!(nearly_equal(value[0], -212f32 / 507.0f32));
462		assert!(nearly_equal(value[1], 55f32 / 338f32));
463		assert!(nearly_equal(value[2], 157f32 / 3042f32));
464		assert!(nearly_equal(value[3], 53f32 / 3042f32));
465		assert!(nearly_equal(value[4], 103f32 / 507f32));
466		assert!(nearly_equal(value[5], -61f32 / 338f32));
467		assert!(nearly_equal(value[6], 127f32 / 3042f32));
468		assert!(nearly_equal(value[7], 101f32 / 3042f32));
469		assert!(nearly_equal(value[8], 79f32 / 507f32));
470		assert!(nearly_equal(value[9], 9f32 / 338f32));
471		assert!(nearly_equal(value[10], -257f32 / 3042f32));
472		assert!(nearly_equal(value[11], 107f32 / 3042f32));
473		assert!(nearly_equal(value[12], 23f32 / 169f32));
474		assert!(nearly_equal(value[13], 5f32 / 169f32));
475		assert!(nearly_equal(value[14], 5f32 / 169f32));
476		assert!(nearly_equal(value[15], -8f32 / 169f32));
477	}
478
479	#[test]
480	fn test_orientation_from_direction() {
481		let dir = maths_rs::Vec3f::from((0f32, 0f32, 1f32));
482		let quaternion = orientation_from_direction(dir);
483		let s = quaternion.as_slice();
484
485		let nearly_equal = |a: f32, b: f32| (a - b).abs() < 0.0001f32;
486
487		assert!(nearly_equal(s[0], 0f32));
488		assert!(nearly_equal(s[1], 0f32));
489		assert!(nearly_equal(s[2], 0f32));
490		assert!(nearly_equal(s[3], 1f32));
491	}
492
493	#[test]
494	fn shader_matrix4_matches_platform_upload_layout() {
495		let matrix = crate::Matrix4::new(
496			1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
497		);
498		let shader_matrix = crate::ShaderMatrix4::from(matrix);
499
500		#[cfg(target_os = "macos")]
501		assert_eq!(
502			shader_matrix.0,
503			[1.0, 5.0, 9.0, 13.0, 2.0, 6.0, 10.0, 14.0, 3.0, 7.0, 11.0, 15.0, 4.0, 8.0, 12.0, 16.0]
504		);
505
506		#[cfg(not(target_os = "macos"))]
507		assert_eq!(
508			shader_matrix.0,
509			[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0]
510		);
511	}
512
513	#[test]
514	fn shader_matrix4x3_preserves_affine_upload_layout() {
515		let matrix = crate::Matrix4::new(
516			1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
517		);
518		let shader_matrix = crate::ShaderMatrix4x3::from(matrix);
519
520		#[cfg(target_os = "macos")]
521		assert_eq!(
522			shader_matrix.0,
523			[1.0, 5.0, 9.0, 0.0, 2.0, 6.0, 10.0, 0.0, 3.0, 7.0, 11.0, 0.0, 4.0, 8.0, 12.0, 0.0]
524		);
525
526		#[cfg(not(target_os = "macos"))]
527		assert_eq!(
528			shader_matrix.0,
529			[1.0, 5.0, 9.0, 2.0, 6.0, 10.0, 3.0, 7.0, 11.0, 4.0, 8.0, 12.0]
530		);
531	}
532
533	#[test]
534	fn shader_matrix4x3_uploads_translation_in_fourth_column() {
535		use crate::mat::MatTranslate as _;
536
537		let matrix = crate::Matrix4::from_translation(crate::Vector3::new(10.0, 20.0, 30.0));
538		let shader_matrix = crate::ShaderMatrix4x3::from(matrix);
539
540		#[cfg(target_os = "macos")]
541		assert_eq!(
542			shader_matrix.0,
543			[1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 10.0, 20.0, 30.0, 0.0]
544		);
545
546		#[cfg(not(target_os = "macos"))]
547		assert_eq!(
548			shader_matrix.0,
549			[1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 10.0, 20.0, 30.0]
550		);
551	}
552}