glam/features/
impl_serde.rs

1macro_rules! impl_serde_vec2 {
2    ($t:ty, $vec2:ident) => {
3        /// Serialize as a sequence of 2 values.
4        impl Serialize for $vec2 {
5            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
6            where
7                S: Serializer,
8            {
9                let mut state = serializer.serialize_tuple_struct(stringify!($vec2), 2)?;
10                state.serialize_field(&self.x)?;
11                state.serialize_field(&self.y)?;
12                state.end()
13            }
14        }
15
16        /// Deserialize expects a sequence of 2 values.
17        impl<'de> Deserialize<'de> for $vec2 {
18            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
19            where
20                D: Deserializer<'de>,
21            {
22                struct Vec2Visitor;
23
24                impl<'de> Visitor<'de> for Vec2Visitor {
25                    type Value = $vec2;
26
27                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
28                        formatter.write_str(&concat!("a sequence of 2 ", stringify!($t), " values"))
29                    }
30
31                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec2, V::Error>
32                    where
33                        V: SeqAccess<'de>,
34                    {
35                        let x = seq
36                            .next_element()?
37                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
38                        let y = seq
39                            .next_element()?
40                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
41                        Ok($vec2::new(x, y))
42                    }
43                }
44
45                deserializer.deserialize_tuple_struct(stringify!($vec2), 2, Vec2Visitor)
46            }
47        }
48
49        #[test]
50        fn test_vec2_serde() {
51            let a = $vec2::new(V1, V2);
52            let serialized = serde_json::to_string(&a).unwrap();
53            assert_eq!(SX2, serialized);
54            let deserialized = serde_json::from_str(&serialized).unwrap();
55            assert_eq!(a, deserialized);
56            let deserialized = serde_json::from_str::<$vec2>(SX0);
57            assert!(deserialized.is_err());
58            let deserialized = serde_json::from_str::<$vec2>(SX1);
59            assert!(deserialized.is_err());
60            let deserialized = serde_json::from_str::<$vec2>(SX3);
61            assert!(deserialized.is_err());
62
63            let deserialized = serde_json::from_str::<$vec2>(ST0);
64            assert!(deserialized.is_err());
65        }
66    };
67}
68
69macro_rules! impl_serde_vec3 {
70    ($t:ty, $vec3:ident) => {
71        impl_serde_vec3!($t, $vec3, test_vec3_serde);
72    };
73    ($t:ty, $vec3:ident, $test_name:ident) => {
74        /// Serialize as a sequence of 3 values.
75        impl Serialize for $vec3 {
76            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
77            where
78                S: Serializer,
79            {
80                let mut state = serializer.serialize_tuple_struct(stringify!($vec3), 3)?;
81                state.serialize_field(&self.x)?;
82                state.serialize_field(&self.y)?;
83                state.serialize_field(&self.z)?;
84                state.end()
85            }
86        }
87
88        /// Deserialize expects a sequence of 3 values.
89        impl<'de> Deserialize<'de> for $vec3 {
90            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
91            where
92                D: Deserializer<'de>,
93            {
94                struct Vec3Visitor;
95
96                impl<'de> Visitor<'de> for Vec3Visitor {
97                    type Value = $vec3;
98
99                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
100                        formatter.write_str(&concat!("a sequence of 3 ", stringify!($t), " values"))
101                    }
102
103                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec3, V::Error>
104                    where
105                        V: SeqAccess<'de>,
106                    {
107                        let x = seq
108                            .next_element()?
109                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
110                        let y = seq
111                            .next_element()?
112                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
113                        let z = seq
114                            .next_element()?
115                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
116                        Ok($vec3::new(x, y, z))
117                    }
118                }
119
120                deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor)
121            }
122        }
123
124        #[test]
125        fn $test_name() {
126            let a = $vec3::new(V1, V2, V3);
127            let serialized = serde_json::to_string(&a).unwrap();
128            assert_eq!(SX3, serialized);
129            let deserialized = serde_json::from_str(&serialized).unwrap();
130            assert_eq!(a, deserialized);
131            let deserialized = serde_json::from_str::<$vec3>(SX0);
132            assert!(deserialized.is_err());
133            let deserialized = serde_json::from_str::<$vec3>(SX1);
134            assert!(deserialized.is_err());
135            let deserialized = serde_json::from_str::<$vec3>(SX2);
136            assert!(deserialized.is_err());
137            let deserialized = serde_json::from_str::<$vec3>(SX4);
138            assert!(deserialized.is_err());
139            let deserialized = serde_json::from_str::<$vec3>(ST0);
140            assert!(deserialized.is_err());
141        }
142    };
143}
144
145macro_rules! impl_serde_vec4 {
146    ($t:ty, $vec4:ident) => {
147        /// Serialize as a sequence of 4 values.
148        impl Serialize for $vec4 {
149            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
150            where
151                S: Serializer,
152            {
153                let mut state = serializer.serialize_tuple_struct(stringify!($vec4), 4)?;
154                state.serialize_field(&self.x)?;
155                state.serialize_field(&self.y)?;
156                state.serialize_field(&self.z)?;
157                state.serialize_field(&self.w)?;
158                state.end()
159            }
160        }
161
162        /// Deserialize expects a sequence of 4 values.
163        impl<'de> Deserialize<'de> for $vec4 {
164            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
165            where
166                D: Deserializer<'de>,
167            {
168                struct Vec4Visitor;
169
170                impl<'de> Visitor<'de> for Vec4Visitor {
171                    type Value = $vec4;
172
173                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
174                        formatter.write_str(&concat!("a sequence of 4 ", stringify!($t), " values"))
175                    }
176
177                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec4, V::Error>
178                    where
179                        V: SeqAccess<'de>,
180                    {
181                        let x = seq
182                            .next_element()?
183                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
184                        let y = seq
185                            .next_element()?
186                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
187                        let z = seq
188                            .next_element()?
189                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
190                        let w = seq
191                            .next_element()?
192                            .ok_or_else(|| de::Error::invalid_length(3, &self))?;
193                        Ok($vec4::new(x, y, z, w))
194                    }
195                }
196
197                deserializer.deserialize_tuple_struct(stringify!($vec4), 4, Vec4Visitor)
198            }
199        }
200
201        #[test]
202        fn test_vec4_serde() {
203            let a = $vec4::new(V1, V2, V3, V4);
204            let serialized = serde_json::to_string(&a).unwrap();
205            assert_eq!(SX4, serialized);
206            let deserialized = serde_json::from_str(&serialized).unwrap();
207            assert_eq!(a, deserialized);
208            let deserialized = serde_json::from_str::<$vec4>(SX0);
209            assert!(deserialized.is_err());
210            let deserialized = serde_json::from_str::<$vec4>(SX1);
211            assert!(deserialized.is_err());
212            let deserialized = serde_json::from_str::<$vec4>(SX2);
213            assert!(deserialized.is_err());
214            let deserialized = serde_json::from_str::<$vec4>(SX3);
215            assert!(deserialized.is_err());
216            let deserialized = serde_json::from_str::<$vec4>(SX5);
217            assert!(deserialized.is_err());
218            let deserialized = serde_json::from_str::<$vec4>(ST0);
219            assert!(deserialized.is_err());
220        }
221    };
222}
223
224macro_rules! impl_serde_quat {
225    ($t:ty, $quat:ident) => {
226        /// Serialize as a sequence of 4 values.
227        impl Serialize for $quat {
228            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
229            where
230                S: Serializer,
231            {
232                let mut state = serializer.serialize_tuple_struct(stringify!($quat), 4)?;
233                state.serialize_field(&self.x)?;
234                state.serialize_field(&self.y)?;
235                state.serialize_field(&self.z)?;
236                state.serialize_field(&self.w)?;
237                state.end()
238            }
239        }
240
241        /// Deserialize expects a sequence of 4 values.
242        impl<'de> Deserialize<'de> for $quat {
243            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
244            where
245                D: Deserializer<'de>,
246            {
247                struct QuatVisitor;
248
249                impl<'de> Visitor<'de> for QuatVisitor {
250                    type Value = $quat;
251
252                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
253                        formatter.write_str(&concat!("a sequence of 4 ", stringify!($t), " values"))
254                    }
255
256                    fn visit_seq<V>(self, mut seq: V) -> Result<$quat, V::Error>
257                    where
258                        V: SeqAccess<'de>,
259                    {
260                        let x = seq
261                            .next_element()?
262                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
263                        let y = seq
264                            .next_element()?
265                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
266                        let z = seq
267                            .next_element()?
268                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
269                        let w = seq
270                            .next_element()?
271                            .ok_or_else(|| de::Error::invalid_length(3, &self))?;
272                        Ok($quat::from_xyzw(x, y, z, w))
273                    }
274                }
275
276                deserializer.deserialize_tuple_struct(stringify!($quat), 4, QuatVisitor)
277            }
278        }
279
280        #[test]
281        fn test_quat_serde() {
282            let a = $quat::from_xyzw(V1, V2, V3, V4);
283            let serialized = serde_json::to_string(&a).unwrap();
284            assert_eq!(serialized, "[1.0,2.0,3.0,4.0]");
285            let deserialized = serde_json::from_str(&serialized).unwrap();
286            assert_eq!(a, deserialized);
287            let deserialized = serde_json::from_str::<$quat>("[]");
288            assert!(deserialized.is_err());
289            let deserialized = serde_json::from_str::<$quat>("[1.0]");
290            assert!(deserialized.is_err());
291            let deserialized = serde_json::from_str::<$quat>("[1.0,2.0]");
292            assert!(deserialized.is_err());
293            let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0]");
294            assert!(deserialized.is_err());
295            let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0,4.0,5.0]");
296            assert!(deserialized.is_err());
297            let deserialized = serde_json::from_str::<$quat>("{}");
298            assert!(deserialized.is_err());
299        }
300    };
301}
302
303macro_rules! impl_serde_mat2 {
304    ($t:ty, $mat2:ident) => {
305        /// Serialize as a sequence of 4 values.
306        impl Serialize for $mat2 {
307            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
308            where
309                S: Serializer,
310            {
311                let f: &[_; 4] = self.as_ref();
312                let mut state = serializer.serialize_tuple_struct(stringify!($mat2), 4)?;
313                state.serialize_field(&f[0])?;
314                state.serialize_field(&f[1])?;
315                state.serialize_field(&f[2])?;
316                state.serialize_field(&f[3])?;
317                state.end()
318            }
319        }
320
321        /// Deserialize expects a sequence of 4 values.
322        impl<'de> Deserialize<'de> for $mat2 {
323            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
324            where
325                D: Deserializer<'de>,
326            {
327                struct Mat2Visitor;
328
329                impl<'de> Visitor<'de> for Mat2Visitor {
330                    type Value = $mat2;
331
332                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
333                        formatter.write_str(&concat!("a sequence of 4 ", stringify!($t), "values"))
334                    }
335
336                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat2, V::Error>
337                    where
338                        V: SeqAccess<'de>,
339                    {
340                        let mut f = { [0.0; 4] };
341                        for i in 0..4 {
342                            f[i] = seq
343                                .next_element()?
344                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
345                        }
346                        Ok($mat2::from_cols_array(&f))
347                    }
348                }
349
350                deserializer.deserialize_tuple_struct(stringify!($mat2), 4, Mat2Visitor)
351            }
352        }
353
354        #[test]
355        fn test_mat2_serde() {
356            let a = $mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]);
357            let serialized = serde_json::to_string(&a).unwrap();
358            assert_eq!(serialized, "[1.0,2.0,3.0,4.0]");
359            let deserialized = serde_json::from_str(&serialized).unwrap();
360            assert_eq!(a, deserialized);
361            let deserialized = serde_json::from_str::<$mat2>("[]");
362            assert!(deserialized.is_err());
363            let deserialized = serde_json::from_str::<$mat2>("[1.0]");
364            assert!(deserialized.is_err());
365            let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0]");
366            assert!(deserialized.is_err());
367            let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0]");
368            assert!(deserialized.is_err());
369            let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0,4.0,5.0]");
370            assert!(deserialized.is_err());
371            let deserialized = serde_json::from_str::<$mat2>("[[1.0,2.0],[3.0,4.0]]");
372            assert!(deserialized.is_err());
373            let deserialized = serde_json::from_str::<$mat2>("{}");
374            assert!(deserialized.is_err());
375        }
376    };
377}
378
379macro_rules! impl_serde_mat3 {
380    ($t:ty, $mat3:ident) => {
381        impl_serde_mat3!($t, $mat3, test_mat3_serde);
382    };
383    ($t:ty, $mat3:ident, $test_name:ident) => {
384        /// Serialize as a sequence of 9 values.
385        impl Serialize for $mat3 {
386            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
387            where
388                S: Serializer,
389            {
390                let (m00, m01, m02) = self.x_axis.into();
391                let (m10, m11, m12) = self.y_axis.into();
392                let (m20, m21, m22) = self.z_axis.into();
393
394                let mut state = serializer.serialize_tuple_struct(stringify!($mat3), 9)?;
395                state.serialize_field(&m00)?;
396                state.serialize_field(&m01)?;
397                state.serialize_field(&m02)?;
398                state.serialize_field(&m10)?;
399                state.serialize_field(&m11)?;
400                state.serialize_field(&m12)?;
401                state.serialize_field(&m20)?;
402                state.serialize_field(&m21)?;
403                state.serialize_field(&m22)?;
404                state.end()
405            }
406        }
407
408        /// Deserialize expects a sequence of 9 values.
409        impl<'de> Deserialize<'de> for $mat3 {
410            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
411            where
412                D: Deserializer<'de>,
413            {
414                struct Mat3Visitor;
415
416                impl<'de> Visitor<'de> for Mat3Visitor {
417                    type Value = $mat3;
418
419                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
420                        formatter.write_str(&concat!("a sequence of 9 ", stringify!($t), "values"))
421                    }
422
423                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat3, V::Error>
424                    where
425                        V: SeqAccess<'de>,
426                    {
427                        let mut f = { [0.0; 9] };
428                        for i in 0..9 {
429                            f[i] = seq
430                                .next_element()?
431                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
432                        }
433                        Ok($mat3::from_cols_array(&f))
434                    }
435                }
436
437                deserializer.deserialize_tuple_struct(stringify!($mat3), 9, Mat3Visitor)
438            }
439        }
440
441        #[test]
442        fn $test_name() {
443            let a = $mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
444            let serialized = serde_json::to_string(&a).unwrap();
445            assert_eq!(serialized, "[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]");
446            let deserialized = serde_json::from_str(&serialized).unwrap();
447            assert_eq!(a, deserialized);
448            let deserialized = serde_json::from_str::<$mat3>("[]");
449            assert!(deserialized.is_err());
450            let deserialized = serde_json::from_str::<$mat3>("[1.0]");
451            assert!(deserialized.is_err());
452            let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0]");
453            assert!(deserialized.is_err());
454            let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0]");
455            assert!(deserialized.is_err());
456            let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0,4.0,5.0]");
457            assert!(deserialized.is_err());
458            let deserialized =
459                serde_json::from_str::<$mat3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
460            assert!(deserialized.is_err());
461            let deserialized = serde_json::from_str::<$mat3>("{}");
462            assert!(deserialized.is_err());
463        }
464    };
465}
466
467macro_rules! impl_serde_mat4 {
468    ($t:ty, $mat4:ident) => {
469        /// Serialize as a sequence of 16 values.
470        impl Serialize for $mat4 {
471            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
472            where
473                S: Serializer,
474            {
475                let mut state = serializer.serialize_tuple_struct(stringify!($mat4), 16)?;
476                for f in self.as_ref() {
477                    state.serialize_field(f)?;
478                }
479                state.end()
480            }
481        }
482
483        /// Deserialize expects a sequence of 16 values.
484        impl<'de> Deserialize<'de> for $mat4 {
485            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
486            where
487                D: Deserializer<'de>,
488            {
489                struct Mat4Visitor;
490
491                impl<'de> Visitor<'de> for Mat4Visitor {
492                    type Value = $mat4;
493
494                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
495                        formatter.write_str(&concat!("a sequence of 16 ", stringify!($t), "values"))
496                    }
497
498                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat4, V::Error>
499                    where
500                        V: SeqAccess<'de>,
501                    {
502                        let mut f = { [0.0; 16] };
503                        for i in 0..16 {
504                            f[i] = seq
505                                .next_element()?
506                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
507                        }
508                        Ok($mat4::from_cols_array(&f))
509                    }
510                }
511
512                deserializer.deserialize_tuple_struct(stringify!($mat4), 16, Mat4Visitor)
513            }
514        }
515
516        #[test]
517        fn test_mat4_serde() {
518            let a = $mat4::from_cols_array(&[
519                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,
520                16.0,
521            ]);
522            let serialized = serde_json::to_string(&a).unwrap();
523            assert_eq!(
524                serialized,
525                "[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]"
526            );
527            let deserialized = serde_json::from_str(&serialized).unwrap();
528            assert_eq!(a, deserialized);
529            let deserialized = serde_json::from_str::<$mat4>("[]");
530            assert!(deserialized.is_err());
531            let deserialized = serde_json::from_str::<$mat4>("[1.0]");
532            assert!(deserialized.is_err());
533            let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0]");
534            assert!(deserialized.is_err());
535            let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0]");
536            assert!(deserialized.is_err());
537            let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0,4.0,5.0]");
538            assert!(deserialized.is_err());
539            let deserialized =
540                serde_json::from_str::<$mat4>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
541            assert!(deserialized.is_err());
542            let deserialized = serde_json::from_str::<$mat4>(
543                "[[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]]",
544            );
545            assert!(deserialized.is_err());
546            let deserialized = serde_json::from_str::<$mat4>("{}");
547            assert!(deserialized.is_err());
548        }
549    };
550}
551
552macro_rules! impl_serde_affine2 {
553    ($t:ty, $affine2:ident) => {
554        /// Serialize as a sequence of 6 values.
555        impl Serialize for $affine2 {
556            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
557            where
558                S: Serializer,
559            {
560                // Serialize column-wise as 3x4 matrix:
561                let mut state = serializer.serialize_tuple_struct(stringify!($affine2), 6)?;
562                state.serialize_field(&self.x_axis.x)?;
563                state.serialize_field(&self.x_axis.y)?;
564                state.serialize_field(&self.y_axis.x)?;
565                state.serialize_field(&self.y_axis.y)?;
566                state.serialize_field(&self.z_axis.x)?;
567                state.serialize_field(&self.z_axis.y)?;
568                state.end()
569            }
570        }
571
572        /// Deserialize expects a sequence of 6 values.
573        impl<'de> Deserialize<'de> for $affine2 {
574            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
575            where
576                D: Deserializer<'de>,
577            {
578                struct Affine2Visitor;
579
580                impl<'de> Visitor<'de> for Affine2Visitor {
581                    type Value = $affine2;
582
583                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
584                        formatter.write_str(&concat!("a sequence of 6 ", stringify!($t), "values"))
585                    }
586
587                    fn visit_seq<V>(self, mut seq: V) -> Result<$affine2, V::Error>
588                    where
589                        V: SeqAccess<'de>,
590                    {
591                        let mut f = [0.0; 6];
592                        for (i, v) in f.iter_mut().enumerate() {
593                            *v = seq
594                                .next_element()?
595                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
596                        }
597                        Ok($affine2::from_cols_array(&f))
598                    }
599                }
600
601                deserializer.deserialize_tuple_struct(stringify!($affine2), 6, Affine2Visitor)
602            }
603        }
604
605        #[test]
606        fn test_affine2_serde() {
607            let a = $affine2::from_cols_array(&[1.0, 0.0, 2.0, 0.0, 3.0, 4.0]);
608            let serialized = serde_json::to_string(&a).unwrap();
609            assert_eq!(serialized, "[1.0,0.0,2.0,0.0,3.0,4.0]");
610            let deserialized = serde_json::from_str(&serialized).unwrap();
611            assert_eq!(a, deserialized);
612
613            let deserialized = serde_json::from_str::<$affine2>("[]");
614            assert!(deserialized.is_err());
615            let deserialized = serde_json::from_str::<$affine2>("[1.0]");
616            assert!(deserialized.is_err());
617            let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0]");
618            assert!(deserialized.is_err());
619            let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0]");
620            assert!(deserialized.is_err());
621            let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0,4.0,5.0]");
622            assert!(deserialized.is_err());
623            let deserialized = serde_json::from_str::<$affine2>("[[1.0,2.0],[3.0,4.0],[5.0,6.0]]");
624            assert!(deserialized.is_err());
625            let deserialized = serde_json::from_str::<$affine2>(
626                "[[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]]",
627            );
628            assert!(deserialized.is_err());
629            let deserialized = serde_json::from_str::<$affine2>("{}");
630            assert!(deserialized.is_err());
631        }
632    };
633}
634
635macro_rules! impl_serde_affine3 {
636    ($testname:ident, $t:ty, $affine3:ident) => {
637        /// Serialize as a sequence of 12 values.
638        impl Serialize for $affine3 {
639            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
640            where
641                S: Serializer,
642            {
643                // Serialize column-wise as 3x4 matrix:
644                let mut state = serializer.serialize_tuple_struct(stringify!($affine3), 12)?;
645                state.serialize_field(&self.x_axis.x)?;
646                state.serialize_field(&self.x_axis.y)?;
647                state.serialize_field(&self.x_axis.z)?;
648                state.serialize_field(&self.y_axis.x)?;
649                state.serialize_field(&self.y_axis.y)?;
650                state.serialize_field(&self.y_axis.z)?;
651                state.serialize_field(&self.z_axis.x)?;
652                state.serialize_field(&self.z_axis.y)?;
653                state.serialize_field(&self.z_axis.z)?;
654                state.serialize_field(&self.w_axis.x)?;
655                state.serialize_field(&self.w_axis.y)?;
656                state.serialize_field(&self.w_axis.z)?;
657                state.end()
658            }
659        }
660
661        /// Deserialize expects a sequence of 12 values.
662        impl<'de> Deserialize<'de> for $affine3 {
663            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
664            where
665                D: Deserializer<'de>,
666            {
667                struct Affine3Visitor;
668
669                impl<'de> Visitor<'de> for Affine3Visitor {
670                    type Value = $affine3;
671
672                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
673                        formatter.write_str(&concat!("a sequence of 12 ", stringify!($t), "values"))
674                    }
675
676                    fn visit_seq<V>(self, mut seq: V) -> Result<$affine3, V::Error>
677                    where
678                        V: SeqAccess<'de>,
679                    {
680                        let mut f = [0.0; 12];
681                        for (i, v) in f.iter_mut().enumerate() {
682                            *v = seq
683                                .next_element()?
684                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
685                        }
686                        Ok($affine3::from_cols_array(&f))
687                    }
688                }
689
690                deserializer.deserialize_tuple_struct(stringify!($affine3), 12, Affine3Visitor)
691            }
692        }
693
694        #[test]
695        fn $testname() {
696            let a = $affine3::from_cols_array(&[
697                1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0, 4.0, 5.0, 6.0,
698            ]);
699            let serialized = serde_json::to_string(&a).unwrap();
700            assert_eq!(
701                serialized,
702                "[1.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,3.0,4.0,5.0,6.0]"
703            );
704            let deserialized = serde_json::from_str(&serialized).unwrap();
705            assert_eq!(a, deserialized);
706
707            let deserialized = serde_json::from_str::<$affine3>("[]");
708            assert!(deserialized.is_err());
709            let deserialized = serde_json::from_str::<$affine3>("[1.0]");
710            assert!(deserialized.is_err());
711            let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0]");
712            assert!(deserialized.is_err());
713            let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0]");
714            assert!(deserialized.is_err());
715            let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0,4.0,5.0]");
716            assert!(deserialized.is_err());
717            let deserialized =
718                serde_json::from_str::<$affine3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
719            assert!(deserialized.is_err());
720            let deserialized = serde_json::from_str::<$affine3>(
721                "[[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]]",
722            );
723            assert!(deserialized.is_err());
724            let deserialized = serde_json::from_str::<$affine3>("{}");
725            assert!(deserialized.is_err());
726        }
727    };
728}
729
730macro_rules! impl_serde_vec_types {
731    ($t:ty, $vec2:ident, $vec3:ident, $vec4:ident) => {
732        impl_serde_vec2!($t, $vec2);
733        impl_serde_vec3!($t, $vec3);
734        impl_serde_vec4!($t, $vec4);
735    };
736}
737
738macro_rules! impl_serde_float_types {
739    ($t:ty, $affine2:ident, $affine3:ident, $mat2:ident, $mat3:ident, $mat4:ident, $quat:ident, $vec2:ident, $vec3:ident, $vec4:ident) => {
740        impl_serde_affine2!($t, $affine2);
741        impl_serde_affine3!(test_affine3_serde, $t, $affine3);
742        impl_serde_mat2!($t, $mat2);
743        impl_serde_mat3!($t, $mat3);
744        impl_serde_mat4!($t, $mat4);
745        impl_serde_quat!($t, $quat);
746        impl_serde_vec_types!($t, $vec2, $vec3, $vec4);
747    };
748}
749
750#[cfg(test)]
751mod test_f32 {
752    pub const V1: f32 = 1.0;
753    pub const V2: f32 = 2.0;
754    pub const V3: f32 = 3.0;
755    pub const V4: f32 = 4.0;
756}
757
758#[cfg(feature = "f64")]
759#[cfg(test)]
760mod test_f64 {
761    pub const V1: f64 = 1.0;
762    pub const V2: f64 = 2.0;
763    pub const V3: f64 = 3.0;
764    pub const V4: f64 = 4.0;
765}
766
767#[cfg(feature = "i8")]
768#[cfg(test)]
769mod test_i8 {
770    pub const V1: i8 = 1;
771    pub const V2: i8 = 2;
772    pub const V3: i8 = 3;
773    pub const V4: i8 = 4;
774}
775
776#[cfg(feature = "i16")]
777#[cfg(test)]
778mod test_i16 {
779    pub const V1: i16 = 1;
780    pub const V2: i16 = 2;
781    pub const V3: i16 = 3;
782    pub const V4: i16 = 4;
783}
784
785#[cfg(feature = "i32")]
786#[cfg(test)]
787mod test_i32 {
788    pub const V1: i32 = 1;
789    pub const V2: i32 = 2;
790    pub const V3: i32 = 3;
791    pub const V4: i32 = 4;
792}
793
794#[cfg(feature = "i64")]
795#[cfg(test)]
796mod test_i64 {
797    pub const V1: i64 = 1;
798    pub const V2: i64 = 2;
799    pub const V3: i64 = 3;
800    pub const V4: i64 = 4;
801}
802
803#[cfg(feature = "isize")]
804#[cfg(test)]
805mod test_isize {
806    pub const V1: isize = 1;
807    pub const V2: isize = 2;
808    pub const V3: isize = 3;
809    pub const V4: isize = 4;
810}
811
812#[cfg(feature = "u8")]
813#[cfg(test)]
814mod test_u8 {
815    pub const V1: u8 = 1;
816    pub const V2: u8 = 2;
817    pub const V3: u8 = 3;
818    pub const V4: u8 = 4;
819}
820
821#[cfg(feature = "u16")]
822#[cfg(test)]
823mod test_u16 {
824    pub const V1: u16 = 1;
825    pub const V2: u16 = 2;
826    pub const V3: u16 = 3;
827    pub const V4: u16 = 4;
828}
829
830#[cfg(feature = "u32")]
831#[cfg(test)]
832mod test_u32 {
833    pub const V1: u32 = 1;
834    pub const V2: u32 = 2;
835    pub const V3: u32 = 3;
836    pub const V4: u32 = 4;
837}
838
839#[cfg(feature = "u64")]
840#[cfg(test)]
841#[allow(dead_code)]
842mod test_u64 {
843    pub const V1: u64 = 1;
844    pub const V2: u64 = 2;
845    pub const V3: u64 = 3;
846    pub const V4: u64 = 4;
847}
848
849#[cfg(feature = "usize")]
850#[cfg(test)]
851mod test_usize {
852    pub const V1: usize = 1;
853    pub const V2: usize = 2;
854    pub const V3: usize = 3;
855    pub const V4: usize = 4;
856}
857
858#[cfg(test)]
859mod test_float {
860    pub const SX0: &str = "[]";
861    pub const SX1: &str = "[1.0]";
862    pub const SX2: &str = "[1.0,2.0]";
863    pub const SX3: &str = "[1.0,2.0,3.0]";
864    pub const SX4: &str = "[1.0,2.0,3.0,4.0]";
865    pub const SX5: &str = "[1.0,2.0,3.0,4.0,5.0]";
866    pub const ST0: &str = "{}";
867}
868
869#[cfg(test)]
870#[allow(dead_code)]
871mod test_int {
872    pub const SX0: &str = "[]";
873    pub const SX1: &str = "[1]";
874    pub const SX2: &str = "[1,2]";
875    pub const SX3: &str = "[1,2,3]";
876    pub const SX4: &str = "[1,2,3,4]";
877    pub const SX5: &str = "[1,2,3,4,5]";
878    pub const ST0: &str = "{}";
879}
880
881#[cfg(test)]
882mod test_bool_mask {
883    pub const SX0: &str = "[]";
884    pub const SX1: &str = "[true]";
885    pub const SX2: &str = "[true,true]";
886    pub const SX3: &str = "[true,true,true]";
887    pub const SX4: &str = "[true,true,true,true]";
888    pub const SX5: &str = "[true,true,true,true,true]";
889    pub const ST0: &str = "{}";
890    pub const V1: bool = true;
891    pub const V2: bool = true;
892    pub const V3: bool = true;
893    pub const V4: bool = true;
894}
895
896mod bool {
897    #[cfg(test)]
898    use super::test_bool_mask::*;
899    use crate::{BVec2, BVec3, BVec4};
900    use crate::{BVec3A, BVec4A};
901    use core::fmt;
902    use serde_core::{
903        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
904        ser::{Serialize, SerializeTupleStruct, Serializer},
905    };
906
907    impl_serde_vec2!(bool, BVec2);
908    impl_serde_vec3!(bool, BVec3);
909    impl_serde_vec4!(bool, BVec4);
910
911    impl Serialize for BVec3A {
912        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
913        where
914            S: Serializer,
915        {
916            let mut state = serializer.serialize_tuple_struct("BVec3A", 3)?;
917            let a: [bool; 3] = (*self).into();
918            state.serialize_field(&a[0])?;
919            state.serialize_field(&a[1])?;
920            state.serialize_field(&a[2])?;
921            state.end()
922        }
923    }
924
925    impl<'de> Deserialize<'de> for BVec3A {
926        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
927        where
928            D: Deserializer<'de>,
929        {
930            struct Vec3Visitor;
931
932            impl<'de> Visitor<'de> for Vec3Visitor {
933                type Value = BVec3A;
934
935                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
936                    formatter.write_str(concat!("a sequence of 3 ", stringify!($t), "values"))
937                }
938
939                fn visit_seq<V>(self, mut seq: V) -> Result<BVec3A, V::Error>
940                where
941                    V: SeqAccess<'de>,
942                {
943                    let x = seq
944                        .next_element()?
945                        .ok_or_else(|| de::Error::invalid_length(0, &self))?;
946                    let y = seq
947                        .next_element()?
948                        .ok_or_else(|| de::Error::invalid_length(1, &self))?;
949                    let z = seq
950                        .next_element()?
951                        .ok_or_else(|| de::Error::invalid_length(2, &self))?;
952                    Ok(BVec3A::new(x, y, z))
953                }
954            }
955
956            deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor)
957        }
958    }
959
960    #[test]
961    fn test_bvec3a_serde() {
962        let a = BVec3A::new(V1, V2, V3);
963        let serialized = serde_json::to_string(&a).unwrap();
964        assert_eq!(SX3, serialized);
965        let deserialized = serde_json::from_str(&serialized).unwrap();
966        assert_eq!(a, deserialized);
967        let deserialized = serde_json::from_str::<BVec3A>(SX0);
968        assert!(deserialized.is_err());
969        let deserialized = serde_json::from_str::<BVec3A>(SX1);
970        assert!(deserialized.is_err());
971        let deserialized = serde_json::from_str::<BVec3A>(SX2);
972        assert!(deserialized.is_err());
973        let deserialized = serde_json::from_str::<BVec3A>(SX4);
974        assert!(deserialized.is_err());
975    }
976
977    impl Serialize for BVec4A {
978        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
979        where
980            S: Serializer,
981        {
982            let mut state = serializer.serialize_tuple_struct(stringify!(BVec4A), 4)?;
983            let a: [bool; 4] = (*self).into();
984            state.serialize_field(&a[0])?;
985            state.serialize_field(&a[1])?;
986            state.serialize_field(&a[2])?;
987            state.serialize_field(&a[2])?;
988            state.end()
989        }
990    }
991
992    impl<'de> Deserialize<'de> for BVec4A {
993        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
994        where
995            D: Deserializer<'de>,
996        {
997            struct Vec4Visitor;
998
999            impl<'de> Visitor<'de> for Vec4Visitor {
1000                type Value = BVec4A;
1001
1002                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
1003                    formatter.write_str(concat!("a sequence of 4 ", stringify!($t), "values"))
1004                }
1005
1006                fn visit_seq<V>(self, mut seq: V) -> Result<BVec4A, V::Error>
1007                where
1008                    V: SeqAccess<'de>,
1009                {
1010                    let x = seq
1011                        .next_element()?
1012                        .ok_or_else(|| de::Error::invalid_length(0, &self))?;
1013                    let y = seq
1014                        .next_element()?
1015                        .ok_or_else(|| de::Error::invalid_length(1, &self))?;
1016                    let z = seq
1017                        .next_element()?
1018                        .ok_or_else(|| de::Error::invalid_length(2, &self))?;
1019                    let w = seq
1020                        .next_element()?
1021                        .ok_or_else(|| de::Error::invalid_length(3, &self))?;
1022                    Ok(BVec4A::new(x, y, z, w))
1023                }
1024            }
1025
1026            deserializer.deserialize_tuple_struct(stringify!(BVec4A), 4, Vec4Visitor)
1027        }
1028    }
1029
1030    #[test]
1031    fn test_bvec4a_serde() {
1032        let a = BVec4A::new(V1, V2, V3, V4);
1033        let serialized = serde_json::to_string(&a).unwrap();
1034        assert_eq!(SX4, serialized);
1035        let deserialized = serde_json::from_str(&serialized).unwrap();
1036        assert_eq!(a, deserialized);
1037        let deserialized = serde_json::from_str::<BVec4A>(SX0);
1038        assert!(deserialized.is_err());
1039        let deserialized = serde_json::from_str::<BVec4A>(SX1);
1040        assert!(deserialized.is_err());
1041        let deserialized = serde_json::from_str::<BVec4A>(SX2);
1042        assert!(deserialized.is_err());
1043        let deserialized = serde_json::from_str::<BVec4A>(SX3);
1044        assert!(deserialized.is_err());
1045        let deserialized = serde_json::from_str::<BVec4A>(SX5);
1046        assert!(deserialized.is_err());
1047    }
1048}
1049
1050mod f32 {
1051    #[cfg(test)]
1052    use super::test_f32::*;
1053    #[cfg(test)]
1054    use super::test_float::*;
1055    use crate::{
1056        Affine2, Affine3, Affine3A, Mat2, Mat3, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4,
1057    };
1058    use core::fmt;
1059    use serde_core::{
1060        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1061        ser::{Serialize, SerializeTupleStruct, Serializer},
1062    };
1063
1064    impl_serde_float_types!(f32, Affine2, Affine3, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec4);
1065    impl_serde_affine3!(test_affine3a_serde, f32, Affine3A);
1066    impl_serde_mat3!(f32, Mat3A, test_mat3a_serde);
1067    impl_serde_vec3!(f32, Vec3A, test_vec3a_serde);
1068}
1069
1070#[cfg(feature = "f64")]
1071mod f64 {
1072    #[cfg(test)]
1073    use super::test_f64::*;
1074    #[cfg(test)]
1075    use super::test_float::*;
1076    use crate::{DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4};
1077    use core::fmt;
1078    use serde_core::{
1079        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1080        ser::{Serialize, SerializeTupleStruct, Serializer},
1081    };
1082
1083    impl_serde_float_types!(
1084        f64, DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4
1085    );
1086}
1087
1088#[cfg(feature = "i8")]
1089mod i8 {
1090    #[cfg(test)]
1091    use super::test_i8::*;
1092    #[cfg(test)]
1093    use super::test_int::*;
1094    use crate::{I8Vec2, I8Vec3, I8Vec4};
1095    use core::fmt;
1096    use serde_core::{
1097        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1098        ser::{Serialize, SerializeTupleStruct, Serializer},
1099    };
1100
1101    impl_serde_vec_types!(i8, I8Vec2, I8Vec3, I8Vec4);
1102}
1103
1104#[cfg(feature = "i16")]
1105mod i16 {
1106    #[cfg(test)]
1107    use super::test_i16::*;
1108    #[cfg(test)]
1109    use super::test_int::*;
1110    use crate::{I16Vec2, I16Vec3, I16Vec4};
1111    use core::fmt;
1112    use serde_core::{
1113        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1114        ser::{Serialize, SerializeTupleStruct, Serializer},
1115    };
1116
1117    impl_serde_vec_types!(i16, I16Vec2, I16Vec3, I16Vec4);
1118}
1119
1120#[cfg(feature = "i32")]
1121mod i32 {
1122    #[cfg(test)]
1123    use super::test_i32::*;
1124    #[cfg(test)]
1125    use super::test_int::*;
1126    use crate::{IVec2, IVec3, IVec4};
1127    use core::fmt;
1128    use serde_core::{
1129        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1130        ser::{Serialize, SerializeTupleStruct, Serializer},
1131    };
1132
1133    impl_serde_vec_types!(i32, IVec2, IVec3, IVec4);
1134}
1135
1136#[cfg(feature = "i64")]
1137mod i64 {
1138    #[cfg(test)]
1139    use super::test_i64::*;
1140    #[cfg(test)]
1141    use super::test_int::*;
1142    use crate::{I64Vec2, I64Vec3, I64Vec4};
1143    use core::fmt;
1144    use serde_core::{
1145        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1146        ser::{Serialize, SerializeTupleStruct, Serializer},
1147    };
1148
1149    impl_serde_vec_types!(i64, I64Vec2, I64Vec3, I64Vec4);
1150}
1151
1152#[cfg(feature = "isize")]
1153mod isize {
1154    #[cfg(test)]
1155    use super::test_int::*;
1156    #[cfg(test)]
1157    use super::test_isize::*;
1158    use crate::{ISizeVec2, ISizeVec3, ISizeVec4};
1159    use core::fmt;
1160    use serde_core::{
1161        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1162        ser::{Serialize, SerializeTupleStruct, Serializer},
1163    };
1164
1165    impl_serde_vec_types!(isize, ISizeVec2, ISizeVec3, ISizeVec4);
1166}
1167
1168#[cfg(feature = "u8")]
1169mod u8 {
1170    #[cfg(test)]
1171    use super::test_int::*;
1172    #[cfg(test)]
1173    use super::test_u8::*;
1174    use crate::{U8Vec2, U8Vec3, U8Vec4};
1175    use core::fmt;
1176    use serde_core::{
1177        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1178        ser::{Serialize, SerializeTupleStruct, Serializer},
1179    };
1180
1181    impl_serde_vec_types!(u8, U8Vec2, U8Vec3, U8Vec4);
1182}
1183
1184#[cfg(feature = "u16")]
1185mod u16 {
1186    #[cfg(test)]
1187    use super::test_int::*;
1188    #[cfg(test)]
1189    use super::test_u16::*;
1190    use crate::{U16Vec2, U16Vec3, U16Vec4};
1191    use core::fmt;
1192    use serde_core::{
1193        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1194        ser::{Serialize, SerializeTupleStruct, Serializer},
1195    };
1196
1197    impl_serde_vec_types!(u16, U16Vec2, U16Vec3, U16Vec4);
1198}
1199
1200#[cfg(feature = "u32")]
1201mod u32 {
1202    #[cfg(test)]
1203    use super::test_int::*;
1204    #[cfg(test)]
1205    use super::test_u32::*;
1206    use crate::{UVec2, UVec3, UVec4};
1207    use core::fmt;
1208    use serde_core::{
1209        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1210        ser::{Serialize, SerializeTupleStruct, Serializer},
1211    };
1212
1213    impl_serde_vec_types!(u32, UVec2, UVec3, UVec4);
1214}
1215
1216#[cfg(feature = "u64")]
1217mod u64 {
1218    #[cfg(test)]
1219    use super::test_int::*;
1220    #[cfg(test)]
1221    use super::test_u64::*;
1222    use crate::{U64Vec2, U64Vec3, U64Vec4};
1223    use core::fmt;
1224    use serde_core::{
1225        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1226        ser::{Serialize, SerializeTupleStruct, Serializer},
1227    };
1228
1229    impl_serde_vec_types!(u64, U64Vec2, U64Vec3, U64Vec4);
1230}
1231
1232#[cfg(feature = "usize")]
1233mod usize {
1234    #[cfg(test)]
1235    use super::test_int::*;
1236    #[cfg(test)]
1237    use super::test_usize::*;
1238    use crate::{USizeVec2, USizeVec3, USizeVec4};
1239    use core::fmt;
1240    use serde_core::{
1241        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1242        ser::{Serialize, SerializeTupleStruct, Serializer},
1243    };
1244
1245    impl_serde_vec_types!(usize, USizeVec2, USizeVec3, USizeVec4);
1246}
1247
1248mod euler {
1249    use crate::EulerRot;
1250
1251    impl serde_core::Serialize for EulerRot {
1252        fn serialize<S: serde_core::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1253            match *self {
1254                EulerRot::ZYX => serde_core::Serializer::serialize_unit_variant(
1255                    serializer, "EulerRot", 0u32, "ZYX",
1256                ),
1257                EulerRot::ZXY => serde_core::Serializer::serialize_unit_variant(
1258                    serializer, "EulerRot", 1u32, "ZXY",
1259                ),
1260                EulerRot::YXZ => serde_core::Serializer::serialize_unit_variant(
1261                    serializer, "EulerRot", 2u32, "YXZ",
1262                ),
1263                EulerRot::YZX => serde_core::Serializer::serialize_unit_variant(
1264                    serializer, "EulerRot", 3u32, "YZX",
1265                ),
1266                EulerRot::XYZ => serde_core::Serializer::serialize_unit_variant(
1267                    serializer, "EulerRot", 4u32, "XYZ",
1268                ),
1269                EulerRot::XZY => serde_core::Serializer::serialize_unit_variant(
1270                    serializer, "EulerRot", 5u32, "XZY",
1271                ),
1272                EulerRot::ZYZ => serde_core::Serializer::serialize_unit_variant(
1273                    serializer, "EulerRot", 6u32, "ZYZ",
1274                ),
1275                EulerRot::ZXZ => serde_core::Serializer::serialize_unit_variant(
1276                    serializer, "EulerRot", 7u32, "ZXZ",
1277                ),
1278                EulerRot::YXY => serde_core::Serializer::serialize_unit_variant(
1279                    serializer, "EulerRot", 8u32, "YXY",
1280                ),
1281                EulerRot::YZY => serde_core::Serializer::serialize_unit_variant(
1282                    serializer, "EulerRot", 9u32, "YZY",
1283                ),
1284                EulerRot::XYX => serde_core::Serializer::serialize_unit_variant(
1285                    serializer, "EulerRot", 10u32, "XYX",
1286                ),
1287                EulerRot::XZX => serde_core::Serializer::serialize_unit_variant(
1288                    serializer, "EulerRot", 11u32, "XZX",
1289                ),
1290                EulerRot::ZYXEx => serde_core::Serializer::serialize_unit_variant(
1291                    serializer, "EulerRot", 12u32, "ZYXEx",
1292                ),
1293                EulerRot::ZXYEx => serde_core::Serializer::serialize_unit_variant(
1294                    serializer, "EulerRot", 13u32, "ZXYEx",
1295                ),
1296                EulerRot::YXZEx => serde_core::Serializer::serialize_unit_variant(
1297                    serializer, "EulerRot", 14u32, "YXZEx",
1298                ),
1299                EulerRot::YZXEx => serde_core::Serializer::serialize_unit_variant(
1300                    serializer, "EulerRot", 15u32, "YZXEx",
1301                ),
1302                EulerRot::XYZEx => serde_core::Serializer::serialize_unit_variant(
1303                    serializer, "EulerRot", 16u32, "XYZEx",
1304                ),
1305                EulerRot::XZYEx => serde_core::Serializer::serialize_unit_variant(
1306                    serializer, "EulerRot", 17u32, "XZYEx",
1307                ),
1308                EulerRot::ZYZEx => serde_core::Serializer::serialize_unit_variant(
1309                    serializer, "EulerRot", 18u32, "ZYZEx",
1310                ),
1311                EulerRot::ZXZEx => serde_core::Serializer::serialize_unit_variant(
1312                    serializer, "EulerRot", 19u32, "ZXZEx",
1313                ),
1314                EulerRot::YXYEx => serde_core::Serializer::serialize_unit_variant(
1315                    serializer, "EulerRot", 20u32, "YXYEx",
1316                ),
1317                EulerRot::YZYEx => serde_core::Serializer::serialize_unit_variant(
1318                    serializer, "EulerRot", 21u32, "YZYEx",
1319                ),
1320                EulerRot::XYXEx => serde_core::Serializer::serialize_unit_variant(
1321                    serializer, "EulerRot", 22u32, "XYXEx",
1322                ),
1323                EulerRot::XZXEx => serde_core::Serializer::serialize_unit_variant(
1324                    serializer, "EulerRot", 23u32, "XZXEx",
1325                ),
1326            }
1327        }
1328    }
1329
1330    impl<'de> serde_core::Deserialize<'de> for EulerRot {
1331        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1332        where
1333            D: serde_core::Deserializer<'de>,
1334        {
1335            #[allow(clippy::upper_case_acronyms)]
1336            enum Field {
1337                ZYX,
1338                ZXY,
1339                YXZ,
1340                YZX,
1341                XYZ,
1342                XZY,
1343                ZYZ,
1344                ZXZ,
1345                YXY,
1346                YZY,
1347                XYX,
1348                XZX,
1349                ZYXEx,
1350                ZXYEx,
1351                YXZEx,
1352                YZXEx,
1353                XYZEx,
1354                XZYEx,
1355                ZYZEx,
1356                ZXZEx,
1357                YXYEx,
1358                YZYEx,
1359                XYXEx,
1360                XZXEx,
1361            }
1362            struct FieldVisitor;
1363
1364            impl serde_core::de::Visitor<'_> for FieldVisitor {
1365                type Value = Field;
1366                fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1367                    core::fmt::Formatter::write_str(formatter, "a variant identifier")
1368                }
1369                fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
1370                where
1371                    E: serde_core::de::Error,
1372                {
1373                    match value {
1374                        0u64 => Ok(Field::ZYX),
1375                        1u64 => Ok(Field::ZXY),
1376                        2u64 => Ok(Field::YXZ),
1377                        3u64 => Ok(Field::YZX),
1378                        4u64 => Ok(Field::XYZ),
1379                        5u64 => Ok(Field::XZY),
1380                        6u64 => Ok(Field::ZYZ),
1381                        7u64 => Ok(Field::ZXZ),
1382                        8u64 => Ok(Field::YXY),
1383                        9u64 => Ok(Field::YZY),
1384                        10u64 => Ok(Field::XYX),
1385                        11u64 => Ok(Field::XZX),
1386
1387                        12u64 => Ok(Field::ZYXEx),
1388                        13u64 => Ok(Field::ZXYEx),
1389                        14u64 => Ok(Field::YXZEx),
1390                        15u64 => Ok(Field::YZXEx),
1391                        16u64 => Ok(Field::XYZEx),
1392                        17u64 => Ok(Field::XZYEx),
1393                        18u64 => Ok(Field::ZYZEx),
1394                        19u64 => Ok(Field::ZXZEx),
1395                        20u64 => Ok(Field::YXYEx),
1396                        21u64 => Ok(Field::YZYEx),
1397                        22u64 => Ok(Field::XYXEx),
1398                        23u64 => Ok(Field::XZXEx),
1399                        _ => Err(serde_core::de::Error::invalid_value(
1400                            serde_core::de::Unexpected::Unsigned(value),
1401                            &"variant index 0 <= i < 24",
1402                        )),
1403                    }
1404                }
1405                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1406                where
1407                    E: serde_core::de::Error,
1408                {
1409                    match value {
1410                        "ZYX" => Ok(Field::ZYX),
1411                        "ZXY" => Ok(Field::ZXY),
1412                        "YXZ" => Ok(Field::YXZ),
1413                        "YZX" => Ok(Field::YZX),
1414                        "XYZ" => Ok(Field::XYZ),
1415                        "XZY" => Ok(Field::XZY),
1416                        "ZYZ" => Ok(Field::ZYZ),
1417                        "ZXZ" => Ok(Field::ZXZ),
1418                        "YXY" => Ok(Field::YXY),
1419                        "YZY" => Ok(Field::YZY),
1420                        "XYX" => Ok(Field::XYX),
1421                        "XZX" => Ok(Field::XZX),
1422                        "ZYXEx" => Ok(Field::ZYXEx),
1423                        "ZXYEx" => Ok(Field::ZXYEx),
1424                        "YXZEx" => Ok(Field::YXZEx),
1425                        "YZXEx" => Ok(Field::YZXEx),
1426                        "XYZEx" => Ok(Field::XYZEx),
1427                        "XZYEx" => Ok(Field::XZYEx),
1428                        "ZYZEx" => Ok(Field::ZYZEx),
1429                        "ZXZEx" => Ok(Field::ZXZEx),
1430                        "YXYEx" => Ok(Field::YXYEx),
1431                        "YZYEx" => Ok(Field::YZYEx),
1432                        "XYXEx" => Ok(Field::XYXEx),
1433                        "XZXEx" => Ok(Field::XZXEx),
1434                        _ => Err(serde_core::de::Error::unknown_variant(value, VARIANTS)),
1435                    }
1436                }
1437                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1438                where
1439                    E: serde_core::de::Error,
1440                {
1441                    match value {
1442                        b"ZYX" => Ok(Field::ZYX),
1443                        b"ZXY" => Ok(Field::ZXY),
1444                        b"YXZ" => Ok(Field::YXZ),
1445                        b"YZX" => Ok(Field::YZX),
1446                        b"XYZ" => Ok(Field::XYZ),
1447                        b"XZY" => Ok(Field::XZY),
1448                        b"ZYZ" => Ok(Field::ZYZ),
1449                        b"ZXZ" => Ok(Field::ZXZ),
1450                        b"YXY" => Ok(Field::YXY),
1451                        b"YZY" => Ok(Field::YZY),
1452                        b"XYX" => Ok(Field::XYX),
1453                        b"XZX" => Ok(Field::XZX),
1454                        b"ZYXEx" => Ok(Field::ZYXEx),
1455                        b"ZXYEx" => Ok(Field::ZXYEx),
1456                        b"YXZEx" => Ok(Field::YXZEx),
1457                        b"YZXEx" => Ok(Field::YZXEx),
1458                        b"XYZEx" => Ok(Field::XYZEx),
1459                        b"XZYEx" => Ok(Field::XZYEx),
1460                        b"ZYZEx" => Ok(Field::ZYZEx),
1461                        b"ZXZEx" => Ok(Field::ZXZEx),
1462                        b"YXYEx" => Ok(Field::YXYEx),
1463                        b"YZYEx" => Ok(Field::YZYEx),
1464                        b"XYXEx" => Ok(Field::XYXEx),
1465                        b"XZXEx" => Ok(Field::XZXEx),
1466                        _ => {
1467                            #[cfg(feature = "std")]
1468                            let value = &String::from_utf8_lossy(value);
1469                            #[cfg(not(feature = "std"))]
1470                            let value =
1471                                core::str::from_utf8(value).unwrap_or("\u{fffd}\u{fffd}\u{fffd}");
1472                            Err(serde_core::de::Error::unknown_variant(value, VARIANTS))
1473                        }
1474                    }
1475                }
1476            }
1477            impl<'de> serde_core::Deserialize<'de> for Field {
1478                #[inline]
1479                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1480                where
1481                    D: serde_core::Deserializer<'de>,
1482                {
1483                    serde_core::Deserializer::deserialize_identifier(deserializer, FieldVisitor)
1484                }
1485            }
1486            struct Visitor<'de> {
1487                marker: core::marker::PhantomData<EulerRot>,
1488                lifetime: core::marker::PhantomData<&'de ()>,
1489            }
1490            impl<'de> serde_core::de::Visitor<'de> for Visitor<'de> {
1491                type Value = EulerRot;
1492                fn expecting(
1493                    &self,
1494                    __formatter: &mut core::fmt::Formatter<'_>,
1495                ) -> core::fmt::Result {
1496                    core::fmt::Formatter::write_str(__formatter, "an EulerRot enum")
1497                }
1498                fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1499                where
1500                    A: serde_core::de::EnumAccess<'de>,
1501                {
1502                    match serde_core::de::EnumAccess::variant(data)? {
1503                        (Field::ZYX, variant) => {
1504                            serde_core::de::VariantAccess::unit_variant(variant)?;
1505                            Ok(EulerRot::ZYX)
1506                        }
1507                        (Field::ZXY, variant) => {
1508                            serde_core::de::VariantAccess::unit_variant(variant)?;
1509                            Ok(EulerRot::ZXY)
1510                        }
1511                        (Field::YXZ, variant) => {
1512                            serde_core::de::VariantAccess::unit_variant(variant)?;
1513                            Ok(EulerRot::YXZ)
1514                        }
1515                        (Field::YZX, variant) => {
1516                            serde_core::de::VariantAccess::unit_variant(variant)?;
1517                            Ok(EulerRot::YZX)
1518                        }
1519                        (Field::XYZ, variant) => {
1520                            serde_core::de::VariantAccess::unit_variant(variant)?;
1521                            Ok(EulerRot::XYZ)
1522                        }
1523                        (Field::XZY, variant) => {
1524                            serde_core::de::VariantAccess::unit_variant(variant)?;
1525                            Ok(EulerRot::XZY)
1526                        }
1527
1528                        (Field::ZYZ, variant) => {
1529                            serde_core::de::VariantAccess::unit_variant(variant)?;
1530                            Ok(EulerRot::ZYZ)
1531                        }
1532                        (Field::ZXZ, variant) => {
1533                            serde_core::de::VariantAccess::unit_variant(variant)?;
1534                            Ok(EulerRot::ZXZ)
1535                        }
1536                        (Field::YXY, variant) => {
1537                            serde_core::de::VariantAccess::unit_variant(variant)?;
1538                            Ok(EulerRot::YXY)
1539                        }
1540                        (Field::YZY, variant) => {
1541                            serde_core::de::VariantAccess::unit_variant(variant)?;
1542                            Ok(EulerRot::YZY)
1543                        }
1544                        (Field::XYX, variant) => {
1545                            serde_core::de::VariantAccess::unit_variant(variant)?;
1546                            Ok(EulerRot::XYX)
1547                        }
1548                        (Field::XZX, variant) => {
1549                            serde_core::de::VariantAccess::unit_variant(variant)?;
1550                            Ok(EulerRot::XZX)
1551                        }
1552                        (Field::ZYXEx, variant) => {
1553                            serde_core::de::VariantAccess::unit_variant(variant)?;
1554                            Ok(EulerRot::ZYXEx)
1555                        }
1556                        (Field::ZXYEx, variant) => {
1557                            serde_core::de::VariantAccess::unit_variant(variant)?;
1558                            Ok(EulerRot::ZXYEx)
1559                        }
1560                        (Field::YXZEx, variant) => {
1561                            serde_core::de::VariantAccess::unit_variant(variant)?;
1562                            Ok(EulerRot::YXZEx)
1563                        }
1564                        (Field::YZXEx, variant) => {
1565                            serde_core::de::VariantAccess::unit_variant(variant)?;
1566                            Ok(EulerRot::YZXEx)
1567                        }
1568                        (Field::XYZEx, variant) => {
1569                            serde_core::de::VariantAccess::unit_variant(variant)?;
1570                            Ok(EulerRot::XYZEx)
1571                        }
1572                        (Field::XZYEx, variant) => {
1573                            serde_core::de::VariantAccess::unit_variant(variant)?;
1574                            Ok(EulerRot::XZYEx)
1575                        }
1576                        (Field::ZYZEx, variant) => {
1577                            serde_core::de::VariantAccess::unit_variant(variant)?;
1578                            Ok(EulerRot::ZYZEx)
1579                        }
1580                        (Field::ZXZEx, variant) => {
1581                            serde_core::de::VariantAccess::unit_variant(variant)?;
1582                            Ok(EulerRot::ZXZEx)
1583                        }
1584                        (Field::YXYEx, variant) => {
1585                            serde_core::de::VariantAccess::unit_variant(variant)?;
1586                            Ok(EulerRot::YXYEx)
1587                        }
1588                        (Field::YZYEx, variant) => {
1589                            serde_core::de::VariantAccess::unit_variant(variant)?;
1590                            Ok(EulerRot::YZYEx)
1591                        }
1592                        (Field::XYXEx, variant) => {
1593                            serde_core::de::VariantAccess::unit_variant(variant)?;
1594                            Ok(EulerRot::XYXEx)
1595                        }
1596                        (Field::XZXEx, variant) => {
1597                            serde_core::de::VariantAccess::unit_variant(variant)?;
1598                            Ok(EulerRot::XZXEx)
1599                        }
1600                    }
1601                }
1602            }
1603            const VARIANTS: &[&str] = &[
1604                "ZYX", "ZXY", "YXZ", "YZX", "XYZ", "XZY", "ZYZ", "ZXZ", "YXY", "YZY", "XYX", "XZX",
1605                "ZYXEx", "ZXYEx", "YXZEx", "YZXEx", "XYZEx", "XZYEx", "ZYZEx", "ZXZEx", "YXYEx",
1606                "YZYEx", "XYXEx", "XZXEx",
1607            ];
1608            serde_core::Deserializer::deserialize_enum(
1609                deserializer,
1610                "EulerRot",
1611                VARIANTS,
1612                Visitor {
1613                    marker: core::marker::PhantomData::<EulerRot>,
1614                    lifetime: core::marker::PhantomData,
1615                },
1616            )
1617        }
1618    }
1619
1620    #[test]
1621    fn test_euler_rot_serde() {
1622        const PAIRS: [(EulerRot, &str); 24] = [
1623            (EulerRot::ZYX, "\"ZYX\""),
1624            (EulerRot::ZXY, "\"ZXY\""),
1625            (EulerRot::YXZ, "\"YXZ\""),
1626            (EulerRot::YZX, "\"YZX\""),
1627            (EulerRot::XYZ, "\"XYZ\""),
1628            (EulerRot::XZY, "\"XZY\""),
1629            (EulerRot::ZYZ, "\"ZYZ\""),
1630            (EulerRot::ZXZ, "\"ZXZ\""),
1631            (EulerRot::YXY, "\"YXY\""),
1632            (EulerRot::YZY, "\"YZY\""),
1633            (EulerRot::XYX, "\"XYX\""),
1634            (EulerRot::XZX, "\"XZX\""),
1635            (EulerRot::ZYXEx, "\"ZYXEx\""),
1636            (EulerRot::ZXYEx, "\"ZXYEx\""),
1637            (EulerRot::YXZEx, "\"YXZEx\""),
1638            (EulerRot::YZXEx, "\"YZXEx\""),
1639            (EulerRot::XYZEx, "\"XYZEx\""),
1640            (EulerRot::XZYEx, "\"XZYEx\""),
1641            (EulerRot::ZYZEx, "\"ZYZEx\""),
1642            (EulerRot::ZXZEx, "\"ZXZEx\""),
1643            (EulerRot::YXYEx, "\"YXYEx\""),
1644            (EulerRot::YZYEx, "\"YZYEx\""),
1645            (EulerRot::XYXEx, "\"XYXEx\""),
1646            (EulerRot::XZXEx, "\"XZXEx\""),
1647        ];
1648        for (enum_value, enum_string) in PAIRS {
1649            let serialized = serde_json::to_string(&enum_value).unwrap();
1650            assert_eq!(enum_string, serialized);
1651            let deserialized = serde_json::from_str(&serialized).unwrap();
1652            assert_eq!(enum_value, deserialized);
1653        }
1654    }
1655}
glam/features/impl_serde.rs

glam/features/
impl_serde.rs
