glam/features/
impl_serde.rs

1macro_rules! impl_serde_vec2 {
2    ($t:ty, $vec2:ident) => {
3        impl Serialize for $vec2 {
4            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
5            where
6                S: Serializer,
7            {
8                let mut state = serializer.serialize_tuple_struct(stringify!($vec2), 2)?;
9                state.serialize_field(&self.x)?;
10                state.serialize_field(&self.y)?;
11                state.end()
12            }
13        }
14
15        impl<'de> Deserialize<'de> for $vec2 {
16            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
17            where
18                D: Deserializer<'de>,
19            {
20                struct Vec2Visitor;
21
22                impl<'de> Visitor<'de> for Vec2Visitor {
23                    type Value = $vec2;
24
25                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
26                        formatter.write_str(concat!("struct ", stringify!($vec2)))
27                    }
28
29                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec2, V::Error>
30                    where
31                        V: SeqAccess<'de>,
32                    {
33                        let x = seq
34                            .next_element()?
35                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
36                        let y = seq
37                            .next_element()?
38                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
39                        Ok($vec2::new(x, y))
40                    }
41                }
42
43                deserializer.deserialize_tuple_struct(stringify!($vec2), 2, Vec2Visitor)
44            }
45        }
46
47        #[test]
48        fn test_vec2_serde() {
49            let a = $vec2::new(V1, V2);
50            let serialized = serde_json::to_string(&a).unwrap();
51            assert_eq!(SX2, serialized);
52            let deserialized = serde_json::from_str(&serialized).unwrap();
53            assert_eq!(a, deserialized);
54            let deserialized = serde_json::from_str::<$vec2>(SX0);
55            assert!(deserialized.is_err());
56            let deserialized = serde_json::from_str::<$vec2>(SX1);
57            assert!(deserialized.is_err());
58            let deserialized = serde_json::from_str::<$vec2>(SX3);
59            assert!(deserialized.is_err());
60        }
61    };
62}
63
64macro_rules! impl_serde_vec3 {
65    ($t:ty, $vec3:ident) => {
66        impl_serde_vec3!($t, $vec3, test_vec3_serde);
67    };
68    ($t:ty, $vec3:ident, $test_name:ident) => {
69        impl Serialize for $vec3 {
70            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
71            where
72                S: Serializer,
73            {
74                let mut state = serializer.serialize_tuple_struct(stringify!($vec3), 3)?;
75                state.serialize_field(&self.x)?;
76                state.serialize_field(&self.y)?;
77                state.serialize_field(&self.z)?;
78                state.end()
79            }
80        }
81
82        impl<'de> Deserialize<'de> for $vec3 {
83            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
84            where
85                D: Deserializer<'de>,
86            {
87                struct Vec3Visitor;
88
89                impl<'de> Visitor<'de> for Vec3Visitor {
90                    type Value = $vec3;
91
92                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
93                        formatter.write_str(concat!("struct ", stringify!($vec3)))
94                    }
95
96                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec3, V::Error>
97                    where
98                        V: SeqAccess<'de>,
99                    {
100                        let x = seq
101                            .next_element()?
102                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
103                        let y = seq
104                            .next_element()?
105                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
106                        let z = seq
107                            .next_element()?
108                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
109                        Ok($vec3::new(x, y, z))
110                    }
111                }
112
113                deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor)
114            }
115        }
116
117        #[test]
118        fn $test_name() {
119            let a = $vec3::new(V1, V2, V3);
120            let serialized = serde_json::to_string(&a).unwrap();
121            assert_eq!(SX3, serialized);
122            let deserialized = serde_json::from_str(&serialized).unwrap();
123            assert_eq!(a, deserialized);
124            let deserialized = serde_json::from_str::<$vec3>(SX0);
125            assert!(deserialized.is_err());
126            let deserialized = serde_json::from_str::<$vec3>(SX1);
127            assert!(deserialized.is_err());
128            let deserialized = serde_json::from_str::<$vec3>(SX2);
129            assert!(deserialized.is_err());
130            let deserialized = serde_json::from_str::<$vec3>(SX4);
131            assert!(deserialized.is_err());
132        }
133    };
134}
135
136macro_rules! impl_serde_vec4 {
137    ($t:ty, $vec4:ident) => {
138        impl Serialize for $vec4 {
139            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
140            where
141                S: Serializer,
142            {
143                let mut state = serializer.serialize_tuple_struct(stringify!($vec4), 4)?;
144                state.serialize_field(&self.x)?;
145                state.serialize_field(&self.y)?;
146                state.serialize_field(&self.z)?;
147                state.serialize_field(&self.w)?;
148                state.end()
149            }
150        }
151
152        impl<'de> Deserialize<'de> for $vec4 {
153            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
154            where
155                D: Deserializer<'de>,
156            {
157                struct Vec4Visitor;
158
159                impl<'de> Visitor<'de> for Vec4Visitor {
160                    type Value = $vec4;
161
162                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
163                        formatter.write_str(concat!("struct ", stringify!($vec4)))
164                    }
165
166                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec4, V::Error>
167                    where
168                        V: SeqAccess<'de>,
169                    {
170                        let x = seq
171                            .next_element()?
172                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
173                        let y = seq
174                            .next_element()?
175                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
176                        let z = seq
177                            .next_element()?
178                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
179                        let w = seq
180                            .next_element()?
181                            .ok_or_else(|| de::Error::invalid_length(3, &self))?;
182                        Ok($vec4::new(x, y, z, w))
183                    }
184                }
185
186                deserializer.deserialize_tuple_struct(stringify!($vec4), 4, Vec4Visitor)
187            }
188        }
189
190        #[test]
191        fn test_vec4_serde() {
192            let a = $vec4::new(V1, V2, V3, V4);
193            let serialized = serde_json::to_string(&a).unwrap();
194            assert_eq!(SX4, serialized);
195            let deserialized = serde_json::from_str(&serialized).unwrap();
196            assert_eq!(a, deserialized);
197            let deserialized = serde_json::from_str::<$vec4>(SX0);
198            assert!(deserialized.is_err());
199            let deserialized = serde_json::from_str::<$vec4>(SX1);
200            assert!(deserialized.is_err());
201            let deserialized = serde_json::from_str::<$vec4>(SX2);
202            assert!(deserialized.is_err());
203            let deserialized = serde_json::from_str::<$vec4>(SX3);
204            assert!(deserialized.is_err());
205            let deserialized = serde_json::from_str::<$vec4>(SX5);
206            assert!(deserialized.is_err());
207        }
208    };
209}
210
211macro_rules! impl_serde_quat {
212    ($t:ty, $quat:ident) => {
213        impl Serialize for $quat {
214            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
215            where
216                S: Serializer,
217            {
218                let mut state = serializer.serialize_tuple_struct(stringify!($quat), 4)?;
219                state.serialize_field(&self.x)?;
220                state.serialize_field(&self.y)?;
221                state.serialize_field(&self.z)?;
222                state.serialize_field(&self.w)?;
223                state.end()
224            }
225        }
226
227        impl<'de> Deserialize<'de> for $quat {
228            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
229            where
230                D: Deserializer<'de>,
231            {
232                struct QuatVisitor;
233
234                impl<'de> Visitor<'de> for QuatVisitor {
235                    type Value = $quat;
236
237                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
238                        formatter.write_str(concat!("struct ", stringify!($quat)))
239                    }
240
241                    fn visit_seq<V>(self, mut seq: V) -> Result<$quat, V::Error>
242                    where
243                        V: SeqAccess<'de>,
244                    {
245                        let x = seq
246                            .next_element()?
247                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
248                        let y = seq
249                            .next_element()?
250                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
251                        let z = seq
252                            .next_element()?
253                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
254                        let w = seq
255                            .next_element()?
256                            .ok_or_else(|| de::Error::invalid_length(3, &self))?;
257                        Ok($quat::from_xyzw(x, y, z, w))
258                    }
259                }
260
261                deserializer.deserialize_tuple_struct(stringify!($quat), 4, QuatVisitor)
262            }
263        }
264
265        #[test]
266        fn test_quat_serde() {
267            let a = $quat::from_xyzw(1.0, 2.0, 3.0, 4.0);
268            let serialized = serde_json::to_string(&a).unwrap();
269            assert_eq!(serialized, "[1.0,2.0,3.0,4.0]");
270            let deserialized = serde_json::from_str(&serialized).unwrap();
271            assert_eq!(a, deserialized);
272            let deserialized = serde_json::from_str::<$quat>("[]");
273            assert!(deserialized.is_err());
274            let deserialized = serde_json::from_str::<$quat>("[1.0]");
275            assert!(deserialized.is_err());
276            let deserialized = serde_json::from_str::<$quat>("[1.0,2.0]");
277            assert!(deserialized.is_err());
278            let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0]");
279            assert!(deserialized.is_err());
280            let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0,4.0,5.0]");
281            assert!(deserialized.is_err());
282        }
283    };
284}
285
286macro_rules! impl_serde_mat2 {
287    ($t:ty, $mat2:ident) => {
288        impl Serialize for $mat2 {
289            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
290            where
291                S: Serializer,
292            {
293                let f: &[_; 4] = self.as_ref();
294                let mut state = serializer.serialize_tuple_struct(stringify!($mat2), 4)?;
295                state.serialize_field(&f[0])?;
296                state.serialize_field(&f[1])?;
297                state.serialize_field(&f[2])?;
298                state.serialize_field(&f[3])?;
299                state.end()
300            }
301        }
302
303        impl<'de> Deserialize<'de> for $mat2 {
304            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
305            where
306                D: Deserializer<'de>,
307            {
308                struct Mat2Visitor;
309
310                impl<'de> Visitor<'de> for Mat2Visitor {
311                    type Value = $mat2;
312
313                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
314                        formatter.write_str(concat!("struct ", stringify!($mat2)))
315                    }
316
317                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat2, V::Error>
318                    where
319                        V: SeqAccess<'de>,
320                    {
321                        let mut f = { [0.0; 4] };
322                        for i in 0..4 {
323                            f[i] = seq
324                                .next_element()?
325                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
326                        }
327                        Ok($mat2::from_cols_array(&f))
328                    }
329                }
330
331                deserializer.deserialize_tuple_struct(stringify!($mat2), 4, Mat2Visitor)
332            }
333        }
334
335        #[test]
336        fn test_mat2_serde() {
337            let a = $mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]);
338            let serialized = serde_json::to_string(&a).unwrap();
339            assert_eq!(serialized, "[1.0,2.0,3.0,4.0]");
340            let deserialized = serde_json::from_str(&serialized).unwrap();
341            assert_eq!(a, deserialized);
342            let deserialized = serde_json::from_str::<$mat2>("[]");
343            assert!(deserialized.is_err());
344            let deserialized = serde_json::from_str::<$mat2>("[1.0]");
345            assert!(deserialized.is_err());
346            let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0]");
347            assert!(deserialized.is_err());
348            let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0]");
349            assert!(deserialized.is_err());
350            let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0,4.0,5.0]");
351            assert!(deserialized.is_err());
352            let deserialized = serde_json::from_str::<$mat2>("[[1.0,2.0],[3.0,4.0]]");
353            assert!(deserialized.is_err());
354        }
355    };
356}
357
358macro_rules! impl_serde_mat3 {
359    ($t:ty, $mat3:ident) => {
360        impl_serde_mat3!($t, $mat3, test_mat3_serde);
361    };
362    ($t:ty, $mat3:ident, $test_name:ident) => {
363        impl Serialize for $mat3 {
364            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
365            where
366                S: Serializer,
367            {
368                let (m00, m01, m02) = self.x_axis.into();
369                let (m10, m11, m12) = self.y_axis.into();
370                let (m20, m21, m22) = self.z_axis.into();
371
372                let mut state = serializer.serialize_tuple_struct(stringify!($mat3), 9)?;
373                state.serialize_field(&m00)?;
374                state.serialize_field(&m01)?;
375                state.serialize_field(&m02)?;
376                state.serialize_field(&m10)?;
377                state.serialize_field(&m11)?;
378                state.serialize_field(&m12)?;
379                state.serialize_field(&m20)?;
380                state.serialize_field(&m21)?;
381                state.serialize_field(&m22)?;
382                state.end()
383            }
384        }
385
386        impl<'de> Deserialize<'de> for $mat3 {
387            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
388            where
389                D: Deserializer<'de>,
390            {
391                struct Mat3Visitor;
392
393                impl<'de> Visitor<'de> for Mat3Visitor {
394                    type Value = $mat3;
395
396                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
397                        formatter.write_str(concat!("struct ", stringify!($mat3)))
398                    }
399
400                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat3, V::Error>
401                    where
402                        V: SeqAccess<'de>,
403                    {
404                        let mut f = { [0.0; 9] };
405                        for i in 0..9 {
406                            f[i] = seq
407                                .next_element()?
408                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
409                        }
410                        Ok($mat3::from_cols_array(&f))
411                    }
412                }
413
414                deserializer.deserialize_tuple_struct(stringify!($mat3), 9, Mat3Visitor)
415            }
416        }
417
418        #[test]
419        fn $test_name() {
420            let a = $mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
421            let serialized = serde_json::to_string(&a).unwrap();
422            assert_eq!(serialized, "[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]");
423            let deserialized = serde_json::from_str(&serialized).unwrap();
424            assert_eq!(a, deserialized);
425            let deserialized = serde_json::from_str::<$mat3>("[]");
426            assert!(deserialized.is_err());
427            let deserialized = serde_json::from_str::<$mat3>("[1.0]");
428            assert!(deserialized.is_err());
429            let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0]");
430            assert!(deserialized.is_err());
431            let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0]");
432            assert!(deserialized.is_err());
433            let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0,4.0,5.0]");
434            assert!(deserialized.is_err());
435            let deserialized =
436                serde_json::from_str::<$mat3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
437            assert!(deserialized.is_err());
438        }
439    };
440}
441
442macro_rules! impl_serde_mat4 {
443    ($t:ty, $mat4:ident) => {
444        impl Serialize for $mat4 {
445            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
446            where
447                S: Serializer,
448            {
449                let mut state = serializer.serialize_tuple_struct(stringify!($mat4), 16)?;
450                for f in self.as_ref() {
451                    state.serialize_field(f)?;
452                }
453                state.end()
454            }
455        }
456
457        impl<'de> Deserialize<'de> for $mat4 {
458            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
459            where
460                D: Deserializer<'de>,
461            {
462                struct Mat4Visitor;
463
464                impl<'de> Visitor<'de> for Mat4Visitor {
465                    type Value = $mat4;
466
467                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
468                        formatter.write_str(concat!("struct ", stringify!($mat4)))
469                    }
470
471                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat4, V::Error>
472                    where
473                        V: SeqAccess<'de>,
474                    {
475                        let mut f = { [0.0; 16] };
476                        for i in 0..16 {
477                            f[i] = seq
478                                .next_element()?
479                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
480                        }
481                        Ok($mat4::from_cols_array(&f))
482                    }
483                }
484
485                deserializer.deserialize_tuple_struct(stringify!($mat4), 16, Mat4Visitor)
486            }
487        }
488
489        #[test]
490        fn test_mat4_serde() {
491            let a = $mat4::from_cols_array(&[
492                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,
493                16.0,
494            ]);
495            let serialized = serde_json::to_string(&a).unwrap();
496            assert_eq!(
497                serialized,
498                "[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]"
499            );
500            let deserialized = serde_json::from_str(&serialized).unwrap();
501            assert_eq!(a, deserialized);
502            let deserialized = serde_json::from_str::<$mat4>("[]");
503            assert!(deserialized.is_err());
504            let deserialized = serde_json::from_str::<$mat4>("[1.0]");
505            assert!(deserialized.is_err());
506            let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0]");
507            assert!(deserialized.is_err());
508            let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0]");
509            assert!(deserialized.is_err());
510            let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0,4.0,5.0]");
511            assert!(deserialized.is_err());
512            let deserialized =
513                serde_json::from_str::<$mat4>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
514            assert!(deserialized.is_err());
515            let deserialized = serde_json::from_str::<$mat4>(
516                "[[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]]",
517            );
518            assert!(deserialized.is_err());
519        }
520    };
521}
522
523macro_rules! impl_serde_affine2 {
524    ($t:ty, $affine2:ident) => {
525        impl Serialize for $affine2 {
526            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
527            where
528                S: Serializer,
529            {
530                // Serialize column-wise as 3x4 matrix:
531                let mut state = serializer.serialize_tuple_struct(stringify!($affine2), 6)?;
532                state.serialize_field(&self.x_axis.x)?;
533                state.serialize_field(&self.x_axis.y)?;
534                state.serialize_field(&self.y_axis.x)?;
535                state.serialize_field(&self.y_axis.y)?;
536                state.serialize_field(&self.z_axis.x)?;
537                state.serialize_field(&self.z_axis.y)?;
538                state.end()
539            }
540        }
541
542        impl<'de> Deserialize<'de> for $affine2 {
543            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
544            where
545                D: Deserializer<'de>,
546            {
547                struct Affine2Visitor;
548
549                impl<'de> Visitor<'de> for Affine2Visitor {
550                    type Value = $affine2;
551
552                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
553                        formatter.write_str("struct $affine2")
554                    }
555
556                    fn visit_seq<V>(self, mut seq: V) -> Result<$affine2, V::Error>
557                    where
558                        V: SeqAccess<'de>,
559                    {
560                        let mut f = [0.0; 6];
561                        for (i, v) in f.iter_mut().enumerate() {
562                            *v = seq
563                                .next_element()?
564                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
565                        }
566                        Ok($affine2::from_cols_array(&f))
567                    }
568                }
569
570                deserializer.deserialize_tuple_struct(stringify!($affine2), 6, Affine2Visitor)
571            }
572        }
573
574        #[test]
575        fn test_affine2_serde() {
576            let a = $affine2::from_cols_array(&[1.0, 0.0, 2.0, 0.0, 3.0, 4.0]);
577            let serialized = serde_json::to_string(&a).unwrap();
578            assert_eq!(serialized, "[1.0,0.0,2.0,0.0,3.0,4.0]");
579            let deserialized = serde_json::from_str(&serialized).unwrap();
580            assert_eq!(a, deserialized);
581
582            let deserialized = serde_json::from_str::<$affine2>("[]");
583            assert!(deserialized.is_err());
584            let deserialized = serde_json::from_str::<$affine2>("[1.0]");
585            assert!(deserialized.is_err());
586            let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0]");
587            assert!(deserialized.is_err());
588            let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0]");
589            assert!(deserialized.is_err());
590            let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0,4.0,5.0]");
591            assert!(deserialized.is_err());
592            let deserialized = serde_json::from_str::<$affine2>("[[1.0,2.0],[3.0,4.0],[5.0,6.0]]");
593            assert!(deserialized.is_err());
594            let deserialized = serde_json::from_str::<$affine2>(
595                "[[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]]",
596            );
597            assert!(deserialized.is_err());
598        }
599    };
600}
601
602macro_rules! impl_serde_affine3 {
603    ($t:ty, $affine3:ident) => {
604        impl Serialize for $affine3 {
605            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
606            where
607                S: Serializer,
608            {
609                // Serialize column-wise as 3x4 matrix:
610                let mut state = serializer.serialize_tuple_struct(stringify!($affine3), 12)?;
611                state.serialize_field(&self.x_axis.x)?;
612                state.serialize_field(&self.x_axis.y)?;
613                state.serialize_field(&self.x_axis.z)?;
614                state.serialize_field(&self.y_axis.x)?;
615                state.serialize_field(&self.y_axis.y)?;
616                state.serialize_field(&self.y_axis.z)?;
617                state.serialize_field(&self.z_axis.x)?;
618                state.serialize_field(&self.z_axis.y)?;
619                state.serialize_field(&self.z_axis.z)?;
620                state.serialize_field(&self.w_axis.x)?;
621                state.serialize_field(&self.w_axis.y)?;
622                state.serialize_field(&self.w_axis.z)?;
623                state.end()
624            }
625        }
626
627        impl<'de> Deserialize<'de> for $affine3 {
628            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
629            where
630                D: Deserializer<'de>,
631            {
632                struct Affine3Visitor;
633
634                impl<'de> Visitor<'de> for Affine3Visitor {
635                    type Value = $affine3;
636
637                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
638                        formatter.write_str("struct $affine3")
639                    }
640
641                    fn visit_seq<V>(self, mut seq: V) -> Result<$affine3, V::Error>
642                    where
643                        V: SeqAccess<'de>,
644                    {
645                        let mut f = [0.0; 12];
646                        for (i, v) in f.iter_mut().enumerate() {
647                            *v = seq
648                                .next_element()?
649                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
650                        }
651                        Ok($affine3::from_cols_array(&f))
652                    }
653                }
654
655                deserializer.deserialize_tuple_struct(stringify!($affine3), 12, Affine3Visitor)
656            }
657        }
658
659        #[test]
660        fn test_affine3_serde() {
661            let a = $affine3::from_cols_array(&[
662                1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0, 4.0, 5.0, 6.0,
663            ]);
664            let serialized = serde_json::to_string(&a).unwrap();
665            assert_eq!(
666                serialized,
667                "[1.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,3.0,4.0,5.0,6.0]"
668            );
669            let deserialized = serde_json::from_str(&serialized).unwrap();
670            assert_eq!(a, deserialized);
671
672            let deserialized = serde_json::from_str::<$affine3>("[]");
673            assert!(deserialized.is_err());
674            let deserialized = serde_json::from_str::<$affine3>("[1.0]");
675            assert!(deserialized.is_err());
676            let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0]");
677            assert!(deserialized.is_err());
678            let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0]");
679            assert!(deserialized.is_err());
680            let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0,4.0,5.0]");
681            assert!(deserialized.is_err());
682            let deserialized =
683                serde_json::from_str::<$affine3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
684            assert!(deserialized.is_err());
685            let deserialized = serde_json::from_str::<$affine3>(
686                "[[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]]",
687            );
688            assert!(deserialized.is_err());
689        }
690    };
691}
692
693macro_rules! impl_serde_vec_types {
694    ($t:ty, $vec2:ident, $vec3:ident, $vec4:ident) => {
695        impl_serde_vec2!($t, $vec2);
696        impl_serde_vec3!($t, $vec3);
697        impl_serde_vec4!($t, $vec4);
698    };
699}
700
701macro_rules! impl_serde_float_types {
702    ($t:ty, $affine2:ident, $affine3:ident, $mat2:ident, $mat3:ident, $mat4:ident, $quat:ident, $vec2:ident, $vec3:ident, $vec4:ident) => {
703        impl_serde_affine2!($t, $affine2);
704        impl_serde_affine3!($t, $affine3);
705        impl_serde_mat2!($t, $mat2);
706        impl_serde_mat3!($t, $mat3);
707        impl_serde_mat4!($t, $mat4);
708        impl_serde_quat!($t, $quat);
709        impl_serde_vec_types!($t, $vec2, $vec3, $vec4);
710    };
711}
712
713#[cfg(test)]
714mod test_f32 {
715    pub const V1: f32 = 1.0;
716    pub const V2: f32 = 2.0;
717    pub const V3: f32 = 3.0;
718    pub const V4: f32 = 4.0;
719}
720
721#[cfg(test)]
722mod test_f64 {
723    pub const V1: f64 = 1.0;
724    pub const V2: f64 = 2.0;
725    pub const V3: f64 = 3.0;
726    pub const V4: f64 = 4.0;
727}
728
729#[cfg(test)]
730mod test_i16 {
731    pub const V1: i16 = 1;
732    pub const V2: i16 = 2;
733    pub const V3: i16 = 3;
734    pub const V4: i16 = 4;
735}
736
737#[cfg(test)]
738mod test_i32 {
739    pub const V1: i32 = 1;
740    pub const V2: i32 = 2;
741    pub const V3: i32 = 3;
742    pub const V4: i32 = 4;
743}
744
745#[cfg(test)]
746mod test_i64 {
747    pub const V1: i64 = 1;
748    pub const V2: i64 = 2;
749    pub const V3: i64 = 3;
750    pub const V4: i64 = 4;
751}
752
753#[cfg(test)]
754mod test_u16 {
755    pub const V1: u16 = 1;
756    pub const V2: u16 = 2;
757    pub const V3: u16 = 3;
758    pub const V4: u16 = 4;
759}
760
761#[cfg(test)]
762mod test_u32 {
763    pub const V1: u32 = 1;
764    pub const V2: u32 = 2;
765    pub const V3: u32 = 3;
766    pub const V4: u32 = 4;
767}
768
769#[cfg(test)]
770mod test_u64 {
771    pub const V1: u64 = 1;
772    pub const V2: u64 = 2;
773    pub const V3: u64 = 3;
774    pub const V4: u64 = 4;
775}
776
777#[cfg(test)]
778mod test_float {
779    pub const SX0: &str = "[]";
780    pub const SX1: &str = "[1.0]";
781    pub const SX2: &str = "[1.0,2.0]";
782    pub const SX3: &str = "[1.0,2.0,3.0]";
783    pub const SX4: &str = "[1.0,2.0,3.0,4.0]";
784    pub const SX5: &str = "[1.0,2.0,3.0,4.0,5.0]";
785}
786
787#[cfg(test)]
788mod test_int {
789    pub const SX0: &str = "[]";
790    pub const SX1: &str = "[1]";
791    pub const SX2: &str = "[1,2]";
792    pub const SX3: &str = "[1,2,3]";
793    pub const SX4: &str = "[1,2,3,4]";
794    pub const SX5: &str = "[1,2,3,4,5]";
795}
796
797#[cfg(test)]
798mod test_bool_mask {
799    pub const SX0: &str = "[]";
800    pub const SX1: &str = "[true]";
801    pub const SX2: &str = "[true,true]";
802    pub const SX3: &str = "[true,true,true]";
803    pub const SX4: &str = "[true,true,true,true]";
804    pub const SX5: &str = "[true,true,true,true,true]";
805    pub const V1: bool = true;
806    pub const V2: bool = true;
807    pub const V3: bool = true;
808    pub const V4: bool = true;
809}
810
811mod bool {
812    #[cfg(test)]
813    use super::test_bool_mask::*;
814    use crate::{BVec2, BVec3, BVec4};
815    #[cfg(not(feature = "scalar-math"))]
816    use crate::{BVec3A, BVec4A};
817    use core::fmt;
818    use serde::{
819        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
820        ser::{Serialize, SerializeTupleStruct, Serializer},
821    };
822
823    impl_serde_vec2!(bool, BVec2);
824    impl_serde_vec3!(bool, BVec3);
825    impl_serde_vec4!(bool, BVec4);
826
827    #[cfg(not(feature = "scalar-math"))]
828    impl Serialize for BVec3A {
829        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
830        where
831            S: Serializer,
832        {
833            let mut state = serializer.serialize_tuple_struct("BVec3A", 3)?;
834            let a: [bool; 3] = (*self).into();
835            state.serialize_field(&a[0])?;
836            state.serialize_field(&a[1])?;
837            state.serialize_field(&a[2])?;
838            state.end()
839        }
840    }
841
842    #[cfg(not(feature = "scalar-math"))]
843    impl<'de> Deserialize<'de> for BVec3A {
844        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
845        where
846            D: Deserializer<'de>,
847        {
848            struct Vec3Visitor;
849
850            impl<'de> Visitor<'de> for Vec3Visitor {
851                type Value = BVec3A;
852
853                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
854                    formatter.write_str("struct BVec3A")
855                }
856
857                fn visit_seq<V>(self, mut seq: V) -> Result<BVec3A, V::Error>
858                where
859                    V: SeqAccess<'de>,
860                {
861                    let x = seq
862                        .next_element()?
863                        .ok_or_else(|| de::Error::invalid_length(0, &self))?;
864                    let y = seq
865                        .next_element()?
866                        .ok_or_else(|| de::Error::invalid_length(1, &self))?;
867                    let z = seq
868                        .next_element()?
869                        .ok_or_else(|| de::Error::invalid_length(2, &self))?;
870                    Ok(BVec3A::new(x, y, z))
871                }
872            }
873
874            deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor)
875        }
876    }
877
878    #[cfg(not(feature = "scalar-math"))]
879    #[test]
880    fn test_bvec3a_serde() {
881        let a = BVec3A::new(V1, V2, V3);
882        let serialized = serde_json::to_string(&a).unwrap();
883        assert_eq!(SX3, serialized);
884        let deserialized = serde_json::from_str(&serialized).unwrap();
885        assert_eq!(a, deserialized);
886        let deserialized = serde_json::from_str::<BVec3A>(SX0);
887        assert!(deserialized.is_err());
888        let deserialized = serde_json::from_str::<BVec3A>(SX1);
889        assert!(deserialized.is_err());
890        let deserialized = serde_json::from_str::<BVec3A>(SX2);
891        assert!(deserialized.is_err());
892        let deserialized = serde_json::from_str::<BVec3A>(SX4);
893        assert!(deserialized.is_err());
894    }
895
896    #[cfg(not(feature = "scalar-math"))]
897    impl Serialize for BVec4A {
898        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
899        where
900            S: Serializer,
901        {
902            let mut state = serializer.serialize_tuple_struct(stringify!(BVec4A), 4)?;
903            let a: [bool; 4] = (*self).into();
904            state.serialize_field(&a[0])?;
905            state.serialize_field(&a[1])?;
906            state.serialize_field(&a[2])?;
907            state.serialize_field(&a[2])?;
908            state.end()
909        }
910    }
911
912    #[cfg(not(feature = "scalar-math"))]
913    impl<'de> Deserialize<'de> for BVec4A {
914        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
915        where
916            D: Deserializer<'de>,
917        {
918            struct Vec4Visitor;
919
920            impl<'de> Visitor<'de> for Vec4Visitor {
921                type Value = BVec4A;
922
923                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
924                    formatter.write_str(concat!("struct ", stringify!(BVec4A)))
925                }
926
927                fn visit_seq<V>(self, mut seq: V) -> Result<BVec4A, V::Error>
928                where
929                    V: SeqAccess<'de>,
930                {
931                    let x = seq
932                        .next_element()?
933                        .ok_or_else(|| de::Error::invalid_length(0, &self))?;
934                    let y = seq
935                        .next_element()?
936                        .ok_or_else(|| de::Error::invalid_length(1, &self))?;
937                    let z = seq
938                        .next_element()?
939                        .ok_or_else(|| de::Error::invalid_length(2, &self))?;
940                    let w = seq
941                        .next_element()?
942                        .ok_or_else(|| de::Error::invalid_length(3, &self))?;
943                    Ok(BVec4A::new(x, y, z, w))
944                }
945            }
946
947            deserializer.deserialize_tuple_struct(stringify!(BVec4A), 4, Vec4Visitor)
948        }
949    }
950
951    #[cfg(not(feature = "scalar-math"))]
952    #[test]
953    fn test_bvec4a_serde() {
954        let a = BVec4A::new(V1, V2, V3, V4);
955        let serialized = serde_json::to_string(&a).unwrap();
956        assert_eq!(SX4, serialized);
957        let deserialized = serde_json::from_str(&serialized).unwrap();
958        assert_eq!(a, deserialized);
959        let deserialized = serde_json::from_str::<BVec4A>(SX0);
960        assert!(deserialized.is_err());
961        let deserialized = serde_json::from_str::<BVec4A>(SX1);
962        assert!(deserialized.is_err());
963        let deserialized = serde_json::from_str::<BVec4A>(SX2);
964        assert!(deserialized.is_err());
965        let deserialized = serde_json::from_str::<BVec4A>(SX3);
966        assert!(deserialized.is_err());
967        let deserialized = serde_json::from_str::<BVec4A>(SX5);
968        assert!(deserialized.is_err());
969    }
970}
971
972mod f32 {
973    #[cfg(test)]
974    use super::test_f32::*;
975    #[cfg(test)]
976    use super::test_float::*;
977    use crate::{Affine2, Affine3A, Mat2, Mat3, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4};
978    use core::fmt;
979    use serde::{
980        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
981        ser::{Serialize, SerializeTupleStruct, Serializer},
982    };
983
984    impl_serde_float_types!(f32, Affine2, Affine3A, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec4);
985    impl_serde_mat3!(f32, Mat3A, test_mat3a_serde);
986    impl_serde_vec3!(f32, Vec3A, test_vec3a_serde);
987}
988
989mod f64 {
990    #[cfg(test)]
991    use super::test_f64::*;
992    #[cfg(test)]
993    use super::test_float::*;
994    use crate::{DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4};
995    use core::fmt;
996    use serde::{
997        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
998        ser::{Serialize, SerializeTupleStruct, Serializer},
999    };
1000
1001    impl_serde_float_types!(
1002        f64, DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4
1003    );
1004}
1005
1006mod i16 {
1007    #[cfg(test)]
1008    use super::test_i16::*;
1009    #[cfg(test)]
1010    use super::test_int::*;
1011    use crate::{I16Vec2, I16Vec3, I16Vec4};
1012    use core::fmt;
1013    use serde::{
1014        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1015        ser::{Serialize, SerializeTupleStruct, Serializer},
1016    };
1017
1018    impl_serde_vec_types!(i16, I16Vec2, I16Vec3, I16Vec4);
1019}
1020
1021mod i32 {
1022    #[cfg(test)]
1023    use super::test_i32::*;
1024    #[cfg(test)]
1025    use super::test_int::*;
1026    use crate::{IVec2, IVec3, IVec4};
1027    use core::fmt;
1028    use serde::{
1029        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1030        ser::{Serialize, SerializeTupleStruct, Serializer},
1031    };
1032
1033    impl_serde_vec_types!(i32, IVec2, IVec3, IVec4);
1034}
1035
1036mod i64 {
1037    #[cfg(test)]
1038    use super::test_i64::*;
1039    #[cfg(test)]
1040    use super::test_int::*;
1041    use crate::{I64Vec2, I64Vec3, I64Vec4};
1042    use core::fmt;
1043    use serde::{
1044        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1045        ser::{Serialize, SerializeTupleStruct, Serializer},
1046    };
1047
1048    impl_serde_vec_types!(i64, I64Vec2, I64Vec3, I64Vec4);
1049}
1050
1051mod u16 {
1052    #[cfg(test)]
1053    use super::test_int::*;
1054    #[cfg(test)]
1055    use super::test_u16::*;
1056    use crate::{U16Vec2, U16Vec3, U16Vec4};
1057    use core::fmt;
1058    use serde::{
1059        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1060        ser::{Serialize, SerializeTupleStruct, Serializer},
1061    };
1062
1063    impl_serde_vec_types!(u16, U16Vec2, U16Vec3, U16Vec4);
1064}
1065
1066mod u32 {
1067    #[cfg(test)]
1068    use super::test_int::*;
1069    #[cfg(test)]
1070    use super::test_u32::*;
1071    use crate::{UVec2, UVec3, UVec4};
1072    use core::fmt;
1073    use serde::{
1074        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1075        ser::{Serialize, SerializeTupleStruct, Serializer},
1076    };
1077
1078    impl_serde_vec_types!(u32, UVec2, UVec3, UVec4);
1079}
1080
1081mod u64 {
1082    #[cfg(test)]
1083    use super::test_int::*;
1084    #[cfg(test)]
1085    use super::test_u64::*;
1086    use crate::{U64Vec2, U64Vec3, U64Vec4};
1087    use core::fmt;
1088    use serde::{
1089        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
1090        ser::{Serialize, SerializeTupleStruct, Serializer},
1091    };
1092
1093    impl_serde_vec_types!(u64, U64Vec2, U64Vec3, U64Vec4);
1094}
1095
1096mod euler {
1097    use crate::EulerRot;
1098
1099    impl serde::Serialize for EulerRot {
1100        fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1101            match *self {
1102                EulerRot::ZYX => {
1103                    serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 0u32, "ZYX")
1104                }
1105                EulerRot::ZXY => {
1106                    serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 1u32, "ZXY")
1107                }
1108                EulerRot::YXZ => {
1109                    serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 2u32, "YXZ")
1110                }
1111                EulerRot::YZX => {
1112                    serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 3u32, "YZX")
1113                }
1114                EulerRot::XYZ => {
1115                    serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 4u32, "XYZ")
1116                }
1117                EulerRot::XZY => {
1118                    serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 5u32, "XZY")
1119                }
1120            }
1121        }
1122    }
1123
1124    impl<'de> serde::Deserialize<'de> for EulerRot {
1125        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1126        where
1127            D: serde::Deserializer<'de>,
1128        {
1129            #[allow(clippy::upper_case_acronyms)]
1130            enum Field {
1131                ZYX,
1132                ZXY,
1133                YXZ,
1134                YZX,
1135                XYZ,
1136                XZY,
1137            }
1138            struct FieldVisitor;
1139
1140            impl<'de> serde::de::Visitor<'de> for FieldVisitor {
1141                type Value = Field;
1142                fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1143                    core::fmt::Formatter::write_str(formatter, "variant identifier")
1144                }
1145                fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
1146                where
1147                    E: serde::de::Error,
1148                {
1149                    match value {
1150                        0u64 => Ok(Field::ZYX),
1151                        1u64 => Ok(Field::ZXY),
1152                        2u64 => Ok(Field::YXZ),
1153                        3u64 => Ok(Field::YZX),
1154                        4u64 => Ok(Field::XYZ),
1155                        5u64 => Ok(Field::XZY),
1156                        _ => Err(serde::de::Error::invalid_value(
1157                            serde::de::Unexpected::Unsigned(value),
1158                            &"variant index 0 <= i < 6",
1159                        )),
1160                    }
1161                }
1162                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1163                where
1164                    E: serde::de::Error,
1165                {
1166                    match value {
1167                        "ZYX" => Ok(Field::ZYX),
1168                        "ZXY" => Ok(Field::ZXY),
1169                        "YXZ" => Ok(Field::YXZ),
1170                        "YZX" => Ok(Field::YZX),
1171                        "XYZ" => Ok(Field::XYZ),
1172                        "XZY" => Ok(Field::XZY),
1173                        _ => Err(serde::de::Error::unknown_variant(value, VARIANTS)),
1174                    }
1175                }
1176                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1177                where
1178                    E: serde::de::Error,
1179                {
1180                    match value {
1181                        b"ZYX" => Ok(Field::ZYX),
1182                        b"ZXY" => Ok(Field::ZXY),
1183                        b"YXZ" => Ok(Field::YXZ),
1184                        b"YZX" => Ok(Field::YZX),
1185                        b"XYZ" => Ok(Field::XYZ),
1186                        b"XZY" => Ok(Field::XZY),
1187                        _ => {
1188                            #[cfg(feature = "std")]
1189                            let value = &String::from_utf8_lossy(value);
1190                            #[cfg(not(feature = "std"))]
1191                            let value =
1192                                core::str::from_utf8(value).unwrap_or("\u{fffd}\u{fffd}\u{fffd}");
1193                            Err(serde::de::Error::unknown_variant(value, VARIANTS))
1194                        }
1195                    }
1196                }
1197            }
1198            impl<'de> serde::Deserialize<'de> for Field {
1199                #[inline]
1200                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1201                where
1202                    D: serde::Deserializer<'de>,
1203                {
1204                    serde::Deserializer::deserialize_identifier(deserializer, FieldVisitor)
1205                }
1206            }
1207            struct Visitor<'de> {
1208                marker: core::marker::PhantomData<EulerRot>,
1209                lifetime: core::marker::PhantomData<&'de ()>,
1210            }
1211            impl<'de> serde::de::Visitor<'de> for Visitor<'de> {
1212                type Value = EulerRot;
1213                fn expecting(
1214                    &self,
1215                    __formatter: &mut core::fmt::Formatter<'_>,
1216                ) -> core::fmt::Result {
1217                    core::fmt::Formatter::write_str(__formatter, "enum EulerRot")
1218                }
1219                fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1220                where
1221                    A: serde::de::EnumAccess<'de>,
1222                {
1223                    match serde::de::EnumAccess::variant(data)? {
1224                        (Field::ZYX, variant) => {
1225                            serde::de::VariantAccess::unit_variant(variant)?;
1226                            Ok(EulerRot::ZYX)
1227                        }
1228                        (Field::ZXY, variant) => {
1229                            serde::de::VariantAccess::unit_variant(variant)?;
1230                            Ok(EulerRot::ZXY)
1231                        }
1232                        (Field::YXZ, variant) => {
1233                            serde::de::VariantAccess::unit_variant(variant)?;
1234                            Ok(EulerRot::YXZ)
1235                        }
1236                        (Field::YZX, variant) => {
1237                            serde::de::VariantAccess::unit_variant(variant)?;
1238                            Ok(EulerRot::YZX)
1239                        }
1240                        (Field::XYZ, variant) => {
1241                            serde::de::VariantAccess::unit_variant(variant)?;
1242                            Ok(EulerRot::XYZ)
1243                        }
1244                        (Field::XZY, variant) => {
1245                            serde::de::VariantAccess::unit_variant(variant)?;
1246                            Ok(EulerRot::XZY)
1247                        }
1248                    }
1249                }
1250            }
1251            const VARIANTS: &[&str] = &["ZYX", "ZXY", "YXZ", "YZX", "XYZ", "XZY"];
1252            serde::Deserializer::deserialize_enum(
1253                deserializer,
1254                "EulerRot",
1255                VARIANTS,
1256                Visitor {
1257                    marker: core::marker::PhantomData::<EulerRot>,
1258                    lifetime: core::marker::PhantomData,
1259                },
1260            )
1261        }
1262    }
1263
1264    #[test]
1265    fn test_euler_rot_serde() {
1266        let a = EulerRot::XYZ;
1267        let serialized = serde_json::to_string(&a).unwrap();
1268        assert_eq!("\"XYZ\"", serialized);
1269        let deserialized = serde_json::from_str(&serialized).unwrap();
1270        assert_eq!(a, deserialized);
1271    }
1272}
glam/features/impl_serde.rs

glam/features/
impl_serde.rs
