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(1.0, 2.0, 3.0, 4.0);
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(test)]
759mod test_f64 {
760    pub const V1: f64 = 1.0;
761    pub const V2: f64 = 2.0;
762    pub const V3: f64 = 3.0;
763    pub const V4: f64 = 4.0;
764}
765
766#[cfg(test)]
767mod test_i8 {
768    pub const V1: i8 = 1;
769    pub const V2: i8 = 2;
770    pub const V3: i8 = 3;
771    pub const V4: i8 = 4;
772}
773
774#[cfg(test)]
775mod test_i16 {
776    pub const V1: i16 = 1;
777    pub const V2: i16 = 2;
778    pub const V3: i16 = 3;
779    pub const V4: i16 = 4;
780}
781
782#[cfg(test)]
783mod test_i32 {
784    pub const V1: i32 = 1;
785    pub const V2: i32 = 2;
786    pub const V3: i32 = 3;
787    pub const V4: i32 = 4;
788}
789
790#[cfg(test)]
791mod test_i64 {
792    pub const V1: i64 = 1;
793    pub const V2: i64 = 2;
794    pub const V3: i64 = 3;
795    pub const V4: i64 = 4;
796}
797
798#[cfg(test)]
799mod test_isize {
800    pub const V1: isize = 1;
801    pub const V2: isize = 2;
802    pub const V3: isize = 3;
803    pub const V4: isize = 4;
804}
805
806#[cfg(test)]
807mod test_u8 {
808    pub const V1: u8 = 1;
809    pub const V2: u8 = 2;
810    pub const V3: u8 = 3;
811    pub const V4: u8 = 4;
812}
813
814#[cfg(test)]
815mod test_u16 {
816    pub const V1: u16 = 1;
817    pub const V2: u16 = 2;
818    pub const V3: u16 = 3;
819    pub const V4: u16 = 4;
820}
821
822#[cfg(test)]
823mod test_u32 {
824    pub const V1: u32 = 1;
825    pub const V2: u32 = 2;
826    pub const V3: u32 = 3;
827    pub const V4: u32 = 4;
828}
829
830#[cfg(test)]
831mod test_u64 {
832    pub const V1: u64 = 1;
833    pub const V2: u64 = 2;
834    pub const V3: u64 = 3;
835    pub const V4: u64 = 4;
836}
837
838#[cfg(test)]
839mod test_usize {
840    pub const V1: usize = 1;
841    pub const V2: usize = 2;
842    pub const V3: usize = 3;
843    pub const V4: usize = 4;
844}
845
846#[cfg(test)]
847mod test_float {
848    pub const SX0: &str = "[]";
849    pub const SX1: &str = "[1.0]";
850    pub const SX2: &str = "[1.0,2.0]";
851    pub const SX3: &str = "[1.0,2.0,3.0]";
852    pub const SX4: &str = "[1.0,2.0,3.0,4.0]";
853    pub const SX5: &str = "[1.0,2.0,3.0,4.0,5.0]";
854    pub const ST0: &str = "{}";
855}
856
857#[cfg(test)]
858mod test_int {
859    pub const SX0: &str = "[]";
860    pub const SX1: &str = "[1]";
861    pub const SX2: &str = "[1,2]";
862    pub const SX3: &str = "[1,2,3]";
863    pub const SX4: &str = "[1,2,3,4]";
864    pub const SX5: &str = "[1,2,3,4,5]";
865    pub const ST0: &str = "{}";
866}
867
868#[cfg(test)]
869mod test_bool_mask {
870    pub const SX0: &str = "[]";
871    pub const SX1: &str = "[true]";
872    pub const SX2: &str = "[true,true]";
873    pub const SX3: &str = "[true,true,true]";
874    pub const SX4: &str = "[true,true,true,true]";
875    pub const SX5: &str = "[true,true,true,true,true]";
876    pub const ST0: &str = "{}";
877    pub const V1: bool = true;
878    pub const V2: bool = true;
879    pub const V3: bool = true;
880    pub const V4: bool = true;
881}
882
883mod bool {
884    #[cfg(test)]
885    use super::test_bool_mask::*;
886    use crate::{BVec2, BVec3, BVec4};
887    #[cfg(not(feature = "scalar-math"))]
888    use crate::{BVec3A, BVec4A};
889    use core::fmt;
890    use serde_core::{
891        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
892        ser::{Serialize, SerializeTupleStruct, Serializer},
893    };
894
895    impl_serde_vec2!(bool, BVec2);
896    impl_serde_vec3!(bool, BVec3);
897    impl_serde_vec4!(bool, BVec4);
898
899    #[cfg(not(feature = "scalar-math"))]
900    impl Serialize for BVec3A {
901        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
902        where
903            S: Serializer,
904        {
905            let mut state = serializer.serialize_tuple_struct("BVec3A", 3)?;
906            let a: [bool; 3] = (*self).into();
907            state.serialize_field(&a[0])?;
908            state.serialize_field(&a[1])?;
909            state.serialize_field(&a[2])?;
910            state.end()
911        }
912    }
913
914    #[cfg(not(feature = "scalar-math"))]
915    impl<'de> Deserialize<'de> for BVec3A {
916        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
917        where
918            D: Deserializer<'de>,
919        {
920            struct Vec3Visitor;
921
922            impl<'de> Visitor<'de> for Vec3Visitor {
923                type Value = BVec3A;
924
925                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
926                    formatter.write_str(concat!("a sequence of 3 ", stringify!($t), "values"))
927                }
928
929                fn visit_seq<V>(self, mut seq: V) -> Result<BVec3A, V::Error>
930                where
931                    V: SeqAccess<'de>,
932                {
933                    let x = seq
934                        .next_element()?
935                        .ok_or_else(|| de::Error::invalid_length(0, &self))?;
936                    let y = seq
937                        .next_element()?
938                        .ok_or_else(|| de::Error::invalid_length(1, &self))?;
939                    let z = seq
940                        .next_element()?
941                        .ok_or_else(|| de::Error::invalid_length(2, &self))?;
942                    Ok(BVec3A::new(x, y, z))
943                }
944            }
945
946            deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor)
947        }
948    }
949
950    #[cfg(not(feature = "scalar-math"))]
951    #[test]
952    fn test_bvec3a_serde() {
953        let a = BVec3A::new(V1, V2, V3);
954        let serialized = serde_json::to_string(&a).unwrap();
955        assert_eq!(SX3, serialized);
956        let deserialized = serde_json::from_str(&serialized).unwrap();
957        assert_eq!(a, deserialized);
958        let deserialized = serde_json::from_str::<BVec3A>(SX0);
959        assert!(deserialized.is_err());
960        let deserialized = serde_json::from_str::<BVec3A>(SX1);
961        assert!(deserialized.is_err());
962        let deserialized = serde_json::from_str::<BVec3A>(SX2);
963        assert!(deserialized.is_err());
964        let deserialized = serde_json::from_str::<BVec3A>(SX4);
965        assert!(deserialized.is_err());
966    }
967
968    #[cfg(not(feature = "scalar-math"))]
969    impl Serialize for BVec4A {
970        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
971        where
972            S: Serializer,
973        {
974            let mut state = serializer.serialize_tuple_struct(stringify!(BVec4A), 4)?;
975            let a: [bool; 4] = (*self).into();
976            state.serialize_field(&a[0])?;
977            state.serialize_field(&a[1])?;
978            state.serialize_field(&a[2])?;
979            state.serialize_field(&a[2])?;
980            state.end()
981        }
982    }
983
984    #[cfg(not(feature = "scalar-math"))]
985    impl<'de> Deserialize<'de> for BVec4A {
986        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
987        where
988            D: Deserializer<'de>,
989        {
990            struct Vec4Visitor;
991
992            impl<'de> Visitor<'de> for Vec4Visitor {
993                type Value = BVec4A;
994
995                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
996                    formatter.write_str(concat!("a sequence of 4 ", stringify!($t), "values"))
997                }
998
999                fn visit_seq<V>(self, mut seq: V) -> Result<BVec4A, V::Error>
1000                where
1001                    V: SeqAccess<'de>,
1002                {
1003                    let x = seq
1004                        .next_element()?
1005                        .ok_or_else(|| de::Error::invalid_length(0, &self))?;
1006                    let y = seq
1007                        .next_element()?
1008                        .ok_or_else(|| de::Error::invalid_length(1, &self))?;
1009                    let z = seq
1010                        .next_element()?
1011                        .ok_or_else(|| de::Error::invalid_length(2, &self))?;
1012                    let w = seq
1013                        .next_element()?
1014                        .ok_or_else(|| de::Error::invalid_length(3, &self))?;
1015                    Ok(BVec4A::new(x, y, z, w))
1016                }
1017            }
1018
1019            deserializer.deserialize_tuple_struct(stringify!(BVec4A), 4, Vec4Visitor)
1020        }
1021    }
1022
1023    #[cfg(not(feature = "scalar-math"))]
1024    #[test]
1025    fn test_bvec4a_serde() {
1026        let a = BVec4A::new(V1, V2, V3, V4);
1027        let serialized = serde_json::to_string(&a).unwrap();
1028        assert_eq!(SX4, serialized);
1029        let deserialized = serde_json::from_str(&serialized).unwrap();
1030        assert_eq!(a, deserialized);
1031        let deserialized = serde_json::from_str::<BVec4A>(SX0);
1032        assert!(deserialized.is_err());
1033        let deserialized = serde_json::from_str::<BVec4A>(SX1);
1034        assert!(deserialized.is_err());
1035        let deserialized = serde_json::from_str::<BVec4A>(SX2);
1036        assert!(deserialized.is_err());
1037        let deserialized = serde_json::from_str::<BVec4A>(SX3);
1038        assert!(deserialized.is_err());
1039        let deserialized = serde_json::from_str::<BVec4A>(SX5);
1040        assert!(deserialized.is_err());
1041    }
1042}
1043
1044mod f32 {
1045    #[cfg(test)]
1046    use super::test_f32::*;
1047    #[cfg(test)]
1048    use super::test_float::*;
1049    use crate::{
1050        Affine2, Affine3, Affine3A, Mat2, Mat3, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4,
1051    };
1052    use core::fmt;
1053    use serde_core::{
1054        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1055        ser::{Serialize, SerializeTupleStruct, Serializer},
1056    };
1057
1058    impl_serde_float_types!(f32, Affine2, Affine3, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec4);
1059    impl_serde_affine3!(test_affine3a_serde, f32, Affine3A);
1060    impl_serde_mat3!(f32, Mat3A, test_mat3a_serde);
1061    impl_serde_vec3!(f32, Vec3A, test_vec3a_serde);
1062}
1063
1064mod f64 {
1065    #[cfg(test)]
1066    use super::test_f64::*;
1067    #[cfg(test)]
1068    use super::test_float::*;
1069    use crate::{DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4};
1070    use core::fmt;
1071    use serde_core::{
1072        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1073        ser::{Serialize, SerializeTupleStruct, Serializer},
1074    };
1075
1076    impl_serde_float_types!(
1077        f64, DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4
1078    );
1079}
1080
1081mod i8 {
1082    #[cfg(test)]
1083    use super::test_i8::*;
1084    #[cfg(test)]
1085    use super::test_int::*;
1086    use crate::{I8Vec2, I8Vec3, I8Vec4};
1087    use core::fmt;
1088    use serde_core::{
1089        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1090        ser::{Serialize, SerializeTupleStruct, Serializer},
1091    };
1092
1093    impl_serde_vec_types!(i8, I8Vec2, I8Vec3, I8Vec4);
1094}
1095
1096mod i16 {
1097    #[cfg(test)]
1098    use super::test_i16::*;
1099    #[cfg(test)]
1100    use super::test_int::*;
1101    use crate::{I16Vec2, I16Vec3, I16Vec4};
1102    use core::fmt;
1103    use serde_core::{
1104        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1105        ser::{Serialize, SerializeTupleStruct, Serializer},
1106    };
1107
1108    impl_serde_vec_types!(i16, I16Vec2, I16Vec3, I16Vec4);
1109}
1110
1111mod i32 {
1112    #[cfg(test)]
1113    use super::test_i32::*;
1114    #[cfg(test)]
1115    use super::test_int::*;
1116    use crate::{IVec2, IVec3, IVec4};
1117    use core::fmt;
1118    use serde_core::{
1119        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1120        ser::{Serialize, SerializeTupleStruct, Serializer},
1121    };
1122
1123    impl_serde_vec_types!(i32, IVec2, IVec3, IVec4);
1124}
1125
1126mod i64 {
1127    #[cfg(test)]
1128    use super::test_i64::*;
1129    #[cfg(test)]
1130    use super::test_int::*;
1131    use crate::{I64Vec2, I64Vec3, I64Vec4};
1132    use core::fmt;
1133    use serde_core::{
1134        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1135        ser::{Serialize, SerializeTupleStruct, Serializer},
1136    };
1137
1138    impl_serde_vec_types!(i64, I64Vec2, I64Vec3, I64Vec4);
1139}
1140
1141mod isize {
1142    #[cfg(test)]
1143    use super::test_int::*;
1144    #[cfg(test)]
1145    use super::test_isize::*;
1146    use crate::{ISizeVec2, ISizeVec3, ISizeVec4};
1147    use core::fmt;
1148    use serde_core::{
1149        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1150        ser::{Serialize, SerializeTupleStruct, Serializer},
1151    };
1152
1153    impl_serde_vec_types!(isize, ISizeVec2, ISizeVec3, ISizeVec4);
1154}
1155
1156mod u8 {
1157    #[cfg(test)]
1158    use super::test_int::*;
1159    #[cfg(test)]
1160    use super::test_u8::*;
1161    use crate::{U8Vec2, U8Vec3, U8Vec4};
1162    use core::fmt;
1163    use serde_core::{
1164        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1165        ser::{Serialize, SerializeTupleStruct, Serializer},
1166    };
1167
1168    impl_serde_vec_types!(u8, U8Vec2, U8Vec3, U8Vec4);
1169}
1170
1171mod u16 {
1172    #[cfg(test)]
1173    use super::test_int::*;
1174    #[cfg(test)]
1175    use super::test_u16::*;
1176    use crate::{U16Vec2, U16Vec3, U16Vec4};
1177    use core::fmt;
1178    use serde_core::{
1179        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1180        ser::{Serialize, SerializeTupleStruct, Serializer},
1181    };
1182
1183    impl_serde_vec_types!(u16, U16Vec2, U16Vec3, U16Vec4);
1184}
1185
1186mod u32 {
1187    #[cfg(test)]
1188    use super::test_int::*;
1189    #[cfg(test)]
1190    use super::test_u32::*;
1191    use crate::{UVec2, UVec3, UVec4};
1192    use core::fmt;
1193    use serde_core::{
1194        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1195        ser::{Serialize, SerializeTupleStruct, Serializer},
1196    };
1197
1198    impl_serde_vec_types!(u32, UVec2, UVec3, UVec4);
1199}
1200
1201mod u64 {
1202    #[cfg(test)]
1203    use super::test_int::*;
1204    #[cfg(test)]
1205    use super::test_u64::*;
1206    use crate::{U64Vec2, U64Vec3, U64Vec4};
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!(u64, U64Vec2, U64Vec3, U64Vec4);
1214}
1215
1216mod usize {
1217    #[cfg(test)]
1218    use super::test_int::*;
1219    #[cfg(test)]
1220    use super::test_usize::*;
1221    use crate::{USizeVec2, USizeVec3, USizeVec4};
1222    use core::fmt;
1223    use serde_core::{
1224        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1225        ser::{Serialize, SerializeTupleStruct, Serializer},
1226    };
1227
1228    impl_serde_vec_types!(usize, USizeVec2, USizeVec3, USizeVec4);
1229}
1230
1231mod euler {
1232    use crate::EulerRot;
1233
1234    impl serde_core::Serialize for EulerRot {
1235        fn serialize<S: serde_core::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1236            match *self {
1237                EulerRot::ZYX => serde_core::Serializer::serialize_unit_variant(
1238                    serializer, "EulerRot", 0u32, "ZYX",
1239                ),
1240                EulerRot::ZXY => serde_core::Serializer::serialize_unit_variant(
1241                    serializer, "EulerRot", 1u32, "ZXY",
1242                ),
1243                EulerRot::YXZ => serde_core::Serializer::serialize_unit_variant(
1244                    serializer, "EulerRot", 2u32, "YXZ",
1245                ),
1246                EulerRot::YZX => serde_core::Serializer::serialize_unit_variant(
1247                    serializer, "EulerRot", 3u32, "YZX",
1248                ),
1249                EulerRot::XYZ => serde_core::Serializer::serialize_unit_variant(
1250                    serializer, "EulerRot", 4u32, "XYZ",
1251                ),
1252                EulerRot::XZY => serde_core::Serializer::serialize_unit_variant(
1253                    serializer, "EulerRot", 5u32, "XZY",
1254                ),
1255                EulerRot::ZYZ => serde_core::Serializer::serialize_unit_variant(
1256                    serializer, "EulerRot", 6u32, "ZYZ",
1257                ),
1258                EulerRot::ZXZ => serde_core::Serializer::serialize_unit_variant(
1259                    serializer, "EulerRot", 7u32, "ZXZ",
1260                ),
1261                EulerRot::YXY => serde_core::Serializer::serialize_unit_variant(
1262                    serializer, "EulerRot", 8u32, "YXY",
1263                ),
1264                EulerRot::YZY => serde_core::Serializer::serialize_unit_variant(
1265                    serializer, "EulerRot", 9u32, "YZY",
1266                ),
1267                EulerRot::XYX => serde_core::Serializer::serialize_unit_variant(
1268                    serializer, "EulerRot", 10u32, "XYX",
1269                ),
1270                EulerRot::XZX => serde_core::Serializer::serialize_unit_variant(
1271                    serializer, "EulerRot", 11u32, "XZX",
1272                ),
1273                EulerRot::ZYXEx => serde_core::Serializer::serialize_unit_variant(
1274                    serializer, "EulerRot", 12u32, "ZYXEx",
1275                ),
1276                EulerRot::ZXYEx => serde_core::Serializer::serialize_unit_variant(
1277                    serializer, "EulerRot", 13u32, "ZXYEx",
1278                ),
1279                EulerRot::YXZEx => serde_core::Serializer::serialize_unit_variant(
1280                    serializer, "EulerRot", 14u32, "YXZEx",
1281                ),
1282                EulerRot::YZXEx => serde_core::Serializer::serialize_unit_variant(
1283                    serializer, "EulerRot", 15u32, "YZXEx",
1284                ),
1285                EulerRot::XYZEx => serde_core::Serializer::serialize_unit_variant(
1286                    serializer, "EulerRot", 16u32, "XYZEx",
1287                ),
1288                EulerRot::XZYEx => serde_core::Serializer::serialize_unit_variant(
1289                    serializer, "EulerRot", 17u32, "XZYEx",
1290                ),
1291                EulerRot::ZYZEx => serde_core::Serializer::serialize_unit_variant(
1292                    serializer, "EulerRot", 18u32, "ZYZEx",
1293                ),
1294                EulerRot::ZXZEx => serde_core::Serializer::serialize_unit_variant(
1295                    serializer, "EulerRot", 19u32, "ZXZEx",
1296                ),
1297                EulerRot::YXYEx => serde_core::Serializer::serialize_unit_variant(
1298                    serializer, "EulerRot", 20u32, "YXYEx",
1299                ),
1300                EulerRot::YZYEx => serde_core::Serializer::serialize_unit_variant(
1301                    serializer, "EulerRot", 21u32, "YZYEx",
1302                ),
1303                EulerRot::XYXEx => serde_core::Serializer::serialize_unit_variant(
1304                    serializer, "EulerRot", 22u32, "XYXEx",
1305                ),
1306                EulerRot::XZXEx => serde_core::Serializer::serialize_unit_variant(
1307                    serializer, "EulerRot", 23u32, "XZXEx",
1308                ),
1309            }
1310        }
1311    }
1312
1313    impl<'de> serde_core::Deserialize<'de> for EulerRot {
1314        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1315        where
1316            D: serde_core::Deserializer<'de>,
1317        {
1318            #[allow(clippy::upper_case_acronyms)]
1319            enum Field {
1320                ZYX,
1321                ZXY,
1322                YXZ,
1323                YZX,
1324                XYZ,
1325                XZY,
1326                ZYZ,
1327                ZXZ,
1328                YXY,
1329                YZY,
1330                XYX,
1331                XZX,
1332                ZYXEx,
1333                ZXYEx,
1334                YXZEx,
1335                YZXEx,
1336                XYZEx,
1337                XZYEx,
1338                ZYZEx,
1339                ZXZEx,
1340                YXYEx,
1341                YZYEx,
1342                XYXEx,
1343                XZXEx,
1344            }
1345            struct FieldVisitor;
1346
1347            impl serde_core::de::Visitor<'_> for FieldVisitor {
1348                type Value = Field;
1349                fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1350                    core::fmt::Formatter::write_str(formatter, "a variant identifier")
1351                }
1352                fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
1353                where
1354                    E: serde_core::de::Error,
1355                {
1356                    match value {
1357                        0u64 => Ok(Field::ZYX),
1358                        1u64 => Ok(Field::ZXY),
1359                        2u64 => Ok(Field::YXZ),
1360                        3u64 => Ok(Field::YZX),
1361                        4u64 => Ok(Field::XYZ),
1362                        5u64 => Ok(Field::XZY),
1363                        6u64 => Ok(Field::ZYZ),
1364                        7u64 => Ok(Field::ZXZ),
1365                        8u64 => Ok(Field::YXY),
1366                        9u64 => Ok(Field::YZY),
1367                        10u64 => Ok(Field::XYX),
1368                        11u64 => Ok(Field::XZX),
1369
1370                        12u64 => Ok(Field::ZYXEx),
1371                        13u64 => Ok(Field::ZXYEx),
1372                        14u64 => Ok(Field::YXZEx),
1373                        15u64 => Ok(Field::YZXEx),
1374                        16u64 => Ok(Field::XYZEx),
1375                        17u64 => Ok(Field::XZYEx),
1376                        18u64 => Ok(Field::ZYZEx),
1377                        19u64 => Ok(Field::ZXZEx),
1378                        20u64 => Ok(Field::YXYEx),
1379                        21u64 => Ok(Field::YZYEx),
1380                        22u64 => Ok(Field::XYXEx),
1381                        23u64 => Ok(Field::XZXEx),
1382                        _ => Err(serde_core::de::Error::invalid_value(
1383                            serde_core::de::Unexpected::Unsigned(value),
1384                            &"variant index 0 <= i < 24",
1385                        )),
1386                    }
1387                }
1388                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1389                where
1390                    E: serde_core::de::Error,
1391                {
1392                    match value {
1393                        "ZYX" => Ok(Field::ZYX),
1394                        "ZXY" => Ok(Field::ZXY),
1395                        "YXZ" => Ok(Field::YXZ),
1396                        "YZX" => Ok(Field::YZX),
1397                        "XYZ" => Ok(Field::XYZ),
1398                        "XZY" => Ok(Field::XZY),
1399                        "ZYZ" => Ok(Field::ZYZ),
1400                        "ZXZ" => Ok(Field::ZXZ),
1401                        "YXY" => Ok(Field::YXY),
1402                        "YZY" => Ok(Field::YZY),
1403                        "XYX" => Ok(Field::XYX),
1404                        "XZX" => Ok(Field::XZX),
1405                        "ZYXEx" => Ok(Field::ZYXEx),
1406                        "ZXYEx" => Ok(Field::ZXYEx),
1407                        "YXZEx" => Ok(Field::YXZEx),
1408                        "YZXEx" => Ok(Field::YZXEx),
1409                        "XYZEx" => Ok(Field::XYZEx),
1410                        "XZYEx" => Ok(Field::XZYEx),
1411                        "ZYZEx" => Ok(Field::ZYZEx),
1412                        "ZXZEx" => Ok(Field::ZXZEx),
1413                        "YXYEx" => Ok(Field::YXYEx),
1414                        "YZYEx" => Ok(Field::YZYEx),
1415                        "XYXEx" => Ok(Field::XYXEx),
1416                        "XZXEx" => Ok(Field::XZXEx),
1417                        _ => Err(serde_core::de::Error::unknown_variant(value, VARIANTS)),
1418                    }
1419                }
1420                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1421                where
1422                    E: serde_core::de::Error,
1423                {
1424                    match value {
1425                        b"ZYX" => Ok(Field::ZYX),
1426                        b"ZXY" => Ok(Field::ZXY),
1427                        b"YXZ" => Ok(Field::YXZ),
1428                        b"YZX" => Ok(Field::YZX),
1429                        b"XYZ" => Ok(Field::XYZ),
1430                        b"XZY" => Ok(Field::XZY),
1431                        b"ZYZ" => Ok(Field::ZYZ),
1432                        b"ZXZ" => Ok(Field::ZXZ),
1433                        b"YXY" => Ok(Field::YXY),
1434                        b"YZY" => Ok(Field::YZY),
1435                        b"XYX" => Ok(Field::XYX),
1436                        b"XZX" => Ok(Field::XZX),
1437                        b"ZYXEx" => Ok(Field::ZYXEx),
1438                        b"ZXYEx" => Ok(Field::ZXYEx),
1439                        b"YXZEx" => Ok(Field::YXZEx),
1440                        b"YZXEx" => Ok(Field::YZXEx),
1441                        b"XYZEx" => Ok(Field::XYZEx),
1442                        b"XZYEx" => Ok(Field::XZYEx),
1443                        b"ZYZEx" => Ok(Field::ZYZEx),
1444                        b"ZXZEx" => Ok(Field::ZXZEx),
1445                        b"YXYEx" => Ok(Field::YXYEx),
1446                        b"YZYEx" => Ok(Field::YZYEx),
1447                        b"XYXEx" => Ok(Field::XYXEx),
1448                        b"XZXEx" => Ok(Field::XZXEx),
1449                        _ => {
1450                            #[cfg(feature = "std")]
1451                            let value = &String::from_utf8_lossy(value);
1452                            #[cfg(not(feature = "std"))]
1453                            let value =
1454                                core::str::from_utf8(value).unwrap_or("\u{fffd}\u{fffd}\u{fffd}");
1455                            Err(serde_core::de::Error::unknown_variant(value, VARIANTS))
1456                        }
1457                    }
1458                }
1459            }
1460            impl<'de> serde_core::Deserialize<'de> for Field {
1461                #[inline]
1462                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1463                where
1464                    D: serde_core::Deserializer<'de>,
1465                {
1466                    serde_core::Deserializer::deserialize_identifier(deserializer, FieldVisitor)
1467                }
1468            }
1469            struct Visitor<'de> {
1470                marker: core::marker::PhantomData<EulerRot>,
1471                lifetime: core::marker::PhantomData<&'de ()>,
1472            }
1473            impl<'de> serde_core::de::Visitor<'de> for Visitor<'de> {
1474                type Value = EulerRot;
1475                fn expecting(
1476                    &self,
1477                    __formatter: &mut core::fmt::Formatter<'_>,
1478                ) -> core::fmt::Result {
1479                    core::fmt::Formatter::write_str(__formatter, "an EulerRot enum")
1480                }
1481                fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1482                where
1483                    A: serde_core::de::EnumAccess<'de>,
1484                {
1485                    match serde_core::de::EnumAccess::variant(data)? {
1486                        (Field::ZYX, variant) => {
1487                            serde_core::de::VariantAccess::unit_variant(variant)?;
1488                            Ok(EulerRot::ZYX)
1489                        }
1490                        (Field::ZXY, variant) => {
1491                            serde_core::de::VariantAccess::unit_variant(variant)?;
1492                            Ok(EulerRot::ZXY)
1493                        }
1494                        (Field::YXZ, variant) => {
1495                            serde_core::de::VariantAccess::unit_variant(variant)?;
1496                            Ok(EulerRot::YXZ)
1497                        }
1498                        (Field::YZX, variant) => {
1499                            serde_core::de::VariantAccess::unit_variant(variant)?;
1500                            Ok(EulerRot::YZX)
1501                        }
1502                        (Field::XYZ, variant) => {
1503                            serde_core::de::VariantAccess::unit_variant(variant)?;
1504                            Ok(EulerRot::XYZ)
1505                        }
1506                        (Field::XZY, variant) => {
1507                            serde_core::de::VariantAccess::unit_variant(variant)?;
1508                            Ok(EulerRot::XZY)
1509                        }
1510
1511                        (Field::ZYZ, variant) => {
1512                            serde_core::de::VariantAccess::unit_variant(variant)?;
1513                            Ok(EulerRot::ZYZ)
1514                        }
1515                        (Field::ZXZ, variant) => {
1516                            serde_core::de::VariantAccess::unit_variant(variant)?;
1517                            Ok(EulerRot::ZXZ)
1518                        }
1519                        (Field::YXY, variant) => {
1520                            serde_core::de::VariantAccess::unit_variant(variant)?;
1521                            Ok(EulerRot::YXY)
1522                        }
1523                        (Field::YZY, variant) => {
1524                            serde_core::de::VariantAccess::unit_variant(variant)?;
1525                            Ok(EulerRot::YZY)
1526                        }
1527                        (Field::XYX, variant) => {
1528                            serde_core::de::VariantAccess::unit_variant(variant)?;
1529                            Ok(EulerRot::XYX)
1530                        }
1531                        (Field::XZX, variant) => {
1532                            serde_core::de::VariantAccess::unit_variant(variant)?;
1533                            Ok(EulerRot::XZX)
1534                        }
1535                        (Field::ZYXEx, variant) => {
1536                            serde_core::de::VariantAccess::unit_variant(variant)?;
1537                            Ok(EulerRot::ZYXEx)
1538                        }
1539                        (Field::ZXYEx, variant) => {
1540                            serde_core::de::VariantAccess::unit_variant(variant)?;
1541                            Ok(EulerRot::ZXYEx)
1542                        }
1543                        (Field::YXZEx, variant) => {
1544                            serde_core::de::VariantAccess::unit_variant(variant)?;
1545                            Ok(EulerRot::YXZEx)
1546                        }
1547                        (Field::YZXEx, variant) => {
1548                            serde_core::de::VariantAccess::unit_variant(variant)?;
1549                            Ok(EulerRot::YZXEx)
1550                        }
1551                        (Field::XYZEx, variant) => {
1552                            serde_core::de::VariantAccess::unit_variant(variant)?;
1553                            Ok(EulerRot::XYZEx)
1554                        }
1555                        (Field::XZYEx, variant) => {
1556                            serde_core::de::VariantAccess::unit_variant(variant)?;
1557                            Ok(EulerRot::XZYEx)
1558                        }
1559                        (Field::ZYZEx, variant) => {
1560                            serde_core::de::VariantAccess::unit_variant(variant)?;
1561                            Ok(EulerRot::ZYZEx)
1562                        }
1563                        (Field::ZXZEx, variant) => {
1564                            serde_core::de::VariantAccess::unit_variant(variant)?;
1565                            Ok(EulerRot::ZXZEx)
1566                        }
1567                        (Field::YXYEx, variant) => {
1568                            serde_core::de::VariantAccess::unit_variant(variant)?;
1569                            Ok(EulerRot::YXYEx)
1570                        }
1571                        (Field::YZYEx, variant) => {
1572                            serde_core::de::VariantAccess::unit_variant(variant)?;
1573                            Ok(EulerRot::YZYEx)
1574                        }
1575                        (Field::XYXEx, variant) => {
1576                            serde_core::de::VariantAccess::unit_variant(variant)?;
1577                            Ok(EulerRot::XYXEx)
1578                        }
1579                        (Field::XZXEx, variant) => {
1580                            serde_core::de::VariantAccess::unit_variant(variant)?;
1581                            Ok(EulerRot::XZXEx)
1582                        }
1583                    }
1584                }
1585            }
1586            const VARIANTS: &[&str] = &[
1587                "ZYX", "ZXY", "YXZ", "YZX", "XYZ", "XZY", "ZYZ", "ZXZ", "YXY", "YZY", "XYX", "XZX",
1588                "ZYXEx", "ZXYEx", "YXZEx", "YZXEx", "XYZEx", "XZYEx", "ZYZEx", "ZXZEx", "YXYEx",
1589                "YZYEx", "XYXEx", "XZXEx",
1590            ];
1591            serde_core::Deserializer::deserialize_enum(
1592                deserializer,
1593                "EulerRot",
1594                VARIANTS,
1595                Visitor {
1596                    marker: core::marker::PhantomData::<EulerRot>,
1597                    lifetime: core::marker::PhantomData,
1598                },
1599            )
1600        }
1601    }
1602
1603    #[test]
1604    fn test_euler_rot_serde() {
1605        const PAIRS: [(EulerRot, &str); 24] = [
1606            (EulerRot::ZYX, "\"ZYX\""),
1607            (EulerRot::ZXY, "\"ZXY\""),
1608            (EulerRot::YXZ, "\"YXZ\""),
1609            (EulerRot::YZX, "\"YZX\""),
1610            (EulerRot::XYZ, "\"XYZ\""),
1611            (EulerRot::XZY, "\"XZY\""),
1612            (EulerRot::ZYZ, "\"ZYZ\""),
1613            (EulerRot::ZXZ, "\"ZXZ\""),
1614            (EulerRot::YXY, "\"YXY\""),
1615            (EulerRot::YZY, "\"YZY\""),
1616            (EulerRot::XYX, "\"XYX\""),
1617            (EulerRot::XZX, "\"XZX\""),
1618            (EulerRot::ZYXEx, "\"ZYXEx\""),
1619            (EulerRot::ZXYEx, "\"ZXYEx\""),
1620            (EulerRot::YXZEx, "\"YXZEx\""),
1621            (EulerRot::YZXEx, "\"YZXEx\""),
1622            (EulerRot::XYZEx, "\"XYZEx\""),
1623            (EulerRot::XZYEx, "\"XZYEx\""),
1624            (EulerRot::ZYZEx, "\"ZYZEx\""),
1625            (EulerRot::ZXZEx, "\"ZXZEx\""),
1626            (EulerRot::YXYEx, "\"YXYEx\""),
1627            (EulerRot::YZYEx, "\"YZYEx\""),
1628            (EulerRot::XYXEx, "\"XYXEx\""),
1629            (EulerRot::XZXEx, "\"XZXEx\""),
1630        ];
1631        for (enum_value, enum_string) in PAIRS {
1632            let serialized = serde_json::to_string(&enum_value).unwrap();
1633            assert_eq!(enum_string, serialized);
1634            let deserialized = serde_json::from_str(&serialized).unwrap();
1635            assert_eq!(enum_value, deserialized);
1636        }
1637    }
1638}
glam/features/impl_serde.rs

glam/features/
impl_serde.rs
