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#[repr(C, align(16))]
85#[derive(Clone, Copy, Debug, Default, PartialEq)]
86pub struct ShaderMatrix4(pub [f32; 16]);
87
88#[repr(C, align(16))]
90#[derive(Clone, Copy, Debug, Default, PartialEq)]
91#[cfg(target_os = "macos")]
92pub struct ShaderMatrix4x3(pub [f32; 16]);
93
94#[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
136pub 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
141pub 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 let dir = normalize(direction);
247
248 let forward = Vector3::new(0.0, 0.0, 1.0);
250
251 let dot = dot(forward, dir);
253 if dot > 0.9999 {
254 return Quaternion::identity();
255 } else if dot < -0.9999 {
256 return Quaternion::from_axis_angle(Vector3::new(1.0, 0.0, 0.0), std::f32::consts::PI);
258 }
259
260 let axis = normalize(cross(forward, dir));
262
263 let angle = dot.acos();
265
266 Quaternion::from_axis_angle(axis, angle)
267}
268
269pub fn direction_from_orientation(orientation: Quaternion) -> Vector3 {
270 let forward = Vector3::new(0.0, 0.0, 1.0);
272 let rotated_forward = orientation * forward;
273 normalize(rotated_forward)
274}
275
276pub 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}