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

glam/features/
impl_serde.rs
