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

glam/features/
impl_serde.rs
