1 macro_rules! impl_vec_types {
2     ($t:ty, $vec2:ident, $vec3:ident, $vec4:ident) => {
3         impl Distribution<$vec2> for Standard {
4             #[inline]
5             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $vec2 {
6                 rng.gen::<[$t; 2]>().into()
7             }
8         }
9 
10         impl Distribution<$vec3> for Standard {
11             #[inline]
12             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $vec3 {
13                 rng.gen::<[$t; 3]>().into()
14             }
15         }
16 
17         impl Distribution<$vec4> for Standard {
18             #[inline]
19             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $vec4 {
20                 rng.gen::<[$t; 4]>().into()
21             }
22         }
23 
24         #[test]
25         fn test_vec2_rand() {
26             use rand::{Rng, SeedableRng};
27             use rand_xoshiro::Xoshiro256Plus;
28             let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
29             let a: ($t, $t) = rng1.gen();
30             let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
31             let b: $vec2 = rng2.gen();
32             assert_eq!(a, b.into());
33         }
34 
35         #[test]
36         fn test_vec3_rand() {
37             use rand::{Rng, SeedableRng};
38             use rand_xoshiro::Xoshiro256Plus;
39             let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
40             let a: ($t, $t, $t) = rng1.gen();
41             let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
42             let b: $vec3 = rng2.gen();
43             assert_eq!(a, b.into());
44         }
45 
46         #[test]
47         fn test_vec4_rand() {
48             use rand::{Rng, SeedableRng};
49             use rand_xoshiro::Xoshiro256Plus;
50             let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
51             let a: ($t, $t, $t, $t) = rng1.gen();
52             let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
53             let b: $vec4 = rng2.gen();
54             assert_eq!(a, b.into());
55         }
56     };
57 }
58 
59 macro_rules! impl_float_types {
60     ($t:ident, $mat2:ident, $mat3:ident, $mat4:ident, $quat:ident, $vec2:ident, $vec3:ident, $vec4:ident) => {
61         impl_vec_types!($t, $vec2, $vec3, $vec4);
62 
63         impl Distribution<$mat2> for Standard {
64             #[inline]
65             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $mat2 {
66                 $mat2::from_cols_array(&rng.gen())
67             }
68         }
69 
70         impl Distribution<$mat3> for Standard {
71             #[inline]
72             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $mat3 {
73                 $mat3::from_cols_array(&rng.gen())
74             }
75         }
76 
77         impl Distribution<$mat4> for Standard {
78             #[inline]
79             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $mat4 {
80                 $mat4::from_cols_array(&rng.gen())
81             }
82         }
83 
84         impl Distribution<$quat> for Standard {
85             #[inline]
86             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $quat {
87                 let yaw = -PI + rng.gen::<$t>() * 2.0 * PI;
88                 let pitch = -PI + rng.gen::<$t>() * 2.0 * PI;
89                 let roll = -PI + rng.gen::<$t>() * 2.0 * PI;
90                 $quat::from_euler(crate::EulerRot::YXZ, yaw, pitch, roll)
91             }
92         }
93 
94         #[test]
95         fn test_mat2_rand() {
96             use rand::{Rng, SeedableRng};
97             use rand_xoshiro::Xoshiro256Plus;
98             let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
99             let a = $mat2::from_cols_array(&rng1.gen::<[$t; 4]>());
100             let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
101             let b = rng2.gen::<$mat2>();
102             assert_eq!(a, b);
103         }
104 
105         #[test]
106         fn test_mat3_rand() {
107             use rand::{Rng, SeedableRng};
108             use rand_xoshiro::Xoshiro256Plus;
109             let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
110             let a = $mat3::from_cols_array(&rng1.gen::<[$t; 9]>());
111             let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
112             let b = rng2.gen::<$mat3>();
113             assert_eq!(a, b);
114         }
115 
116         #[test]
117         fn test_mat4_rand() {
118             use rand::{Rng, SeedableRng};
119             use rand_xoshiro::Xoshiro256Plus;
120             let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
121             let a = $mat4::from_cols_array(&rng1.gen::<[$t; 16]>());
122             let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
123             let b = rng2.gen::<$mat4>();
124             assert_eq!(a, b);
125         }
126 
127         #[test]
128         fn test_quat_rand() {
129             use rand::{Rng, SeedableRng};
130             use rand_xoshiro::Xoshiro256Plus;
131             let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
132             let a: $quat = rng1.gen();
133             assert!(a.is_normalized());
134             let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
135             let b: $quat = rng2.gen();
136             assert_eq!(a, b);
137         }
138     };
139 }
140 
141 mod f32 {
142     use crate::{Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4};
143     use core::f32::consts::PI;
144     use rand::{
145         distributions::{Distribution, Standard},
146         Rng,
147     };
148 
149     impl_float_types!(f32, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec4);
150 
151     impl Distribution<Vec3A> for Standard {
152         #[inline]
sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vec3A153         fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vec3A {
154             rng.gen::<[f32; 3]>().into()
155         }
156     }
157 
158     #[test]
test_vec3a_rand()159     fn test_vec3a_rand() {
160         use rand::{Rng, SeedableRng};
161         use rand_xoshiro::Xoshiro256Plus;
162         let mut rng1 = Xoshiro256Plus::seed_from_u64(0);
163         let a: (f32, f32, f32) = rng1.gen();
164         let mut rng2 = Xoshiro256Plus::seed_from_u64(0);
165         let b: Vec3A = rng2.gen();
166         assert_eq!(a, b.into());
167     }
168 }
169 
170 mod f64 {
171     use crate::{DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4};
172     use core::f64::consts::PI;
173     use rand::{
174         distributions::{Distribution, Standard},
175         Rng,
176     };
177 
178     impl_float_types!(f64, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4);
179 }
180 
181 mod i16 {
182     use crate::{I16Vec2, I16Vec3, I16Vec4};
183     use rand::{
184         distributions::{Distribution, Standard},
185         Rng,
186     };
187 
188     impl_vec_types!(i16, I16Vec2, I16Vec3, I16Vec4);
189 }
190 
191 mod i32 {
192     use crate::{IVec2, IVec3, IVec4};
193     use rand::{
194         distributions::{Distribution, Standard},
195         Rng,
196     };
197 
198     impl_vec_types!(i32, IVec2, IVec3, IVec4);
199 }
200 
201 mod i64 {
202     use crate::{I64Vec2, I64Vec3, I64Vec4};
203     use rand::{
204         distributions::{Distribution, Standard},
205         Rng,
206     };
207 
208     impl_vec_types!(i64, I64Vec2, I64Vec3, I64Vec4);
209 }
210 
211 mod u16 {
212     use crate::{U16Vec2, U16Vec3, U16Vec4};
213     use rand::{
214         distributions::{Distribution, Standard},
215         Rng,
216     };
217 
218     impl_vec_types!(u16, U16Vec2, U16Vec3, U16Vec4);
219 }
220 
221 mod u32 {
222     use crate::{UVec2, UVec3, UVec4};
223     use rand::{
224         distributions::{Distribution, Standard},
225         Rng,
226     };
227 
228     impl_vec_types!(u32, UVec2, UVec3, UVec4);
229 }
230 
231 mod u64 {
232     use crate::{U64Vec2, U64Vec3, U64Vec4};
233     use rand::{
234         distributions::{Distribution, Standard},
235         Rng,
236     };
237 
238     impl_vec_types!(u64, U64Vec2, U64Vec3, U64Vec4);
239 }
240