havok_classes/generated/
hkaSplineCompressedAnimationTrackCompressionParams_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkaSplineCompressedAnimationTrackCompressionParams`
5/// - version: `0`
6/// - signature: `0x42e878d3`
7/// - size: ` 28`(x86)/` 28`(x86_64)
8/// -  vtable: `false`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkaSplineCompressedAnimationTrackCompressionParams {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// # C++ Info
27    /// - name: `rotationTolerance`(ctype: `hkReal`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  4`(x86)/`  4`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "rotationTolerance"))]
31    #[cfg_attr(feature = "serde", serde(rename = "rotationTolerance"))]
32    pub m_rotationTolerance: f32,
33    /// # C++ Info
34    /// - name: `translationTolerance`(ctype: `hkReal`)
35    /// - offset: `  4`(x86)/`  4`(x86_64)
36    /// - type_size: `  4`(x86)/`  4`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "translationTolerance"))]
38    #[cfg_attr(feature = "serde", serde(rename = "translationTolerance"))]
39    pub m_translationTolerance: f32,
40    /// # C++ Info
41    /// - name: `scaleTolerance`(ctype: `hkReal`)
42    /// - offset: `  8`(x86)/`  8`(x86_64)
43    /// - type_size: `  4`(x86)/`  4`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "scaleTolerance"))]
45    #[cfg_attr(feature = "serde", serde(rename = "scaleTolerance"))]
46    pub m_scaleTolerance: f32,
47    /// # C++ Info
48    /// - name: `floatingTolerance`(ctype: `hkReal`)
49    /// - offset: ` 12`(x86)/` 12`(x86_64)
50    /// - type_size: `  4`(x86)/`  4`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "floatingTolerance"))]
52    #[cfg_attr(feature = "serde", serde(rename = "floatingTolerance"))]
53    pub m_floatingTolerance: f32,
54    /// # C++ Info
55    /// - name: `rotationDegree`(ctype: `hkUint16`)
56    /// - offset: ` 16`(x86)/` 16`(x86_64)
57    /// - type_size: `  2`(x86)/`  2`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "rotationDegree"))]
59    #[cfg_attr(feature = "serde", serde(rename = "rotationDegree"))]
60    pub m_rotationDegree: u16,
61    /// # C++ Info
62    /// - name: `translationDegree`(ctype: `hkUint16`)
63    /// - offset: ` 18`(x86)/` 18`(x86_64)
64    /// - type_size: `  2`(x86)/`  2`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "translationDegree"))]
66    #[cfg_attr(feature = "serde", serde(rename = "translationDegree"))]
67    pub m_translationDegree: u16,
68    /// # C++ Info
69    /// - name: `scaleDegree`(ctype: `hkUint16`)
70    /// - offset: ` 20`(x86)/` 20`(x86_64)
71    /// - type_size: `  2`(x86)/`  2`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "scaleDegree"))]
73    #[cfg_attr(feature = "serde", serde(rename = "scaleDegree"))]
74    pub m_scaleDegree: u16,
75    /// # C++ Info
76    /// - name: `floatingDegree`(ctype: `hkUint16`)
77    /// - offset: ` 22`(x86)/` 22`(x86_64)
78    /// - type_size: `  2`(x86)/`  2`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "floatingDegree"))]
80    #[cfg_attr(feature = "serde", serde(rename = "floatingDegree"))]
81    pub m_floatingDegree: u16,
82    /// # C++ Info
83    /// - name: `rotationQuantizationType`(ctype: `enum RotationQuantization`)
84    /// - offset: ` 24`(x86)/` 24`(x86_64)
85    /// - type_size: `  1`(x86)/`  1`(x86_64)
86    #[cfg_attr(feature = "json_schema", schemars(rename = "rotationQuantizationType"))]
87    #[cfg_attr(feature = "serde", serde(rename = "rotationQuantizationType"))]
88    pub m_rotationQuantizationType: RotationQuantization,
89    /// # C++ Info
90    /// - name: `translationQuantizationType`(ctype: `enum ScalarQuantization`)
91    /// - offset: ` 25`(x86)/` 25`(x86_64)
92    /// - type_size: `  1`(x86)/`  1`(x86_64)
93    #[cfg_attr(
94        feature = "json_schema",
95        schemars(rename = "translationQuantizationType")
96    )]
97    #[cfg_attr(feature = "serde", serde(rename = "translationQuantizationType"))]
98    pub m_translationQuantizationType: ScalarQuantization,
99    /// # C++ Info
100    /// - name: `scaleQuantizationType`(ctype: `enum ScalarQuantization`)
101    /// - offset: ` 26`(x86)/` 26`(x86_64)
102    /// - type_size: `  1`(x86)/`  1`(x86_64)
103    #[cfg_attr(feature = "json_schema", schemars(rename = "scaleQuantizationType"))]
104    #[cfg_attr(feature = "serde", serde(rename = "scaleQuantizationType"))]
105    pub m_scaleQuantizationType: ScalarQuantization,
106    /// # C++ Info
107    /// - name: `floatQuantizationType`(ctype: `enum ScalarQuantization`)
108    /// - offset: ` 27`(x86)/` 27`(x86_64)
109    /// - type_size: `  1`(x86)/`  1`(x86_64)
110    #[cfg_attr(feature = "json_schema", schemars(rename = "floatQuantizationType"))]
111    #[cfg_attr(feature = "serde", serde(rename = "floatQuantizationType"))]
112    pub m_floatQuantizationType: ScalarQuantization,
113}
114const _: () = {
115    use havok_serde as _serde;
116    impl _serde::HavokClass for hkaSplineCompressedAnimationTrackCompressionParams {
117        #[inline]
118        fn name(&self) -> &'static str {
119            "hkaSplineCompressedAnimationTrackCompressionParams"
120        }
121        #[inline]
122        fn signature(&self) -> _serde::__private::Signature {
123            _serde::__private::Signature::new(0x42e878d3)
124        }
125        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
126        fn deps_indexes(&self) -> Vec<usize> {
127            let mut v = Vec::new();
128            v
129        }
130    }
131    impl _serde::Serialize for hkaSplineCompressedAnimationTrackCompressionParams {
132        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
133        where
134            S: _serde::ser::Serializer,
135        {
136            let class_meta = self
137                .__ptr
138                .map(|name| (name, _serde::__private::Signature::new(0x42e878d3)));
139            let mut serializer = __serializer
140                .serialize_struct(
141                    "hkaSplineCompressedAnimationTrackCompressionParams",
142                    class_meta,
143                    (28u64, 28u64),
144                )?;
145            serializer.serialize_field("rotationTolerance", &self.m_rotationTolerance)?;
146            serializer
147                .serialize_field("translationTolerance", &self.m_translationTolerance)?;
148            serializer.serialize_field("scaleTolerance", &self.m_scaleTolerance)?;
149            serializer.serialize_field("floatingTolerance", &self.m_floatingTolerance)?;
150            serializer.serialize_field("rotationDegree", &self.m_rotationDegree)?;
151            serializer.serialize_field("translationDegree", &self.m_translationDegree)?;
152            serializer.serialize_field("scaleDegree", &self.m_scaleDegree)?;
153            serializer.serialize_field("floatingDegree", &self.m_floatingDegree)?;
154            serializer
155                .serialize_field(
156                    "rotationQuantizationType",
157                    &self.m_rotationQuantizationType,
158                )?;
159            serializer
160                .serialize_field(
161                    "translationQuantizationType",
162                    &self.m_translationQuantizationType,
163                )?;
164            serializer
165                .serialize_field(
166                    "scaleQuantizationType",
167                    &self.m_scaleQuantizationType,
168                )?;
169            serializer
170                .serialize_field(
171                    "floatQuantizationType",
172                    &self.m_floatQuantizationType,
173                )?;
174            serializer.end()
175        }
176    }
177};
178#[doc(hidden)]
179#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
180const _: () = {
181    use havok_serde as _serde;
182    #[automatically_derived]
183    impl<'de> _serde::Deserialize<'de>
184    for hkaSplineCompressedAnimationTrackCompressionParams {
185        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
186        where
187            __D: _serde::Deserializer<'de>,
188        {
189            #[allow(non_camel_case_types)]
190            enum __Field {
191                m_rotationTolerance,
192                m_translationTolerance,
193                m_scaleTolerance,
194                m_floatingTolerance,
195                m_rotationDegree,
196                m_translationDegree,
197                m_scaleDegree,
198                m_floatingDegree,
199                m_rotationQuantizationType,
200                m_translationQuantizationType,
201                m_scaleQuantizationType,
202                m_floatQuantizationType,
203                __ignore,
204            }
205            struct __FieldVisitor;
206            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
207                type Value = __Field;
208                fn expecting(
209                    &self,
210                    __formatter: &mut core::fmt::Formatter,
211                ) -> core::fmt::Result {
212                    core::fmt::Formatter::write_str(__formatter, "field identifier")
213                }
214                /// Intended for use in XML.
215                #[allow(clippy::match_single_binding)]
216                #[allow(clippy::reversed_empty_ranges)]
217                #[allow(clippy::single_match)]
218                fn visit_key<__E>(
219                    self,
220                    __value: &str,
221                ) -> core::result::Result<Self::Value, __E>
222                where
223                    __E: _serde::de::Error,
224                {
225                    match __value {
226                        "rotationTolerance" => Ok(__Field::m_rotationTolerance),
227                        "translationTolerance" => Ok(__Field::m_translationTolerance),
228                        "scaleTolerance" => Ok(__Field::m_scaleTolerance),
229                        "floatingTolerance" => Ok(__Field::m_floatingTolerance),
230                        "rotationDegree" => Ok(__Field::m_rotationDegree),
231                        "translationDegree" => Ok(__Field::m_translationDegree),
232                        "scaleDegree" => Ok(__Field::m_scaleDegree),
233                        "floatingDegree" => Ok(__Field::m_floatingDegree),
234                        "rotationQuantizationType" => {
235                            Ok(__Field::m_rotationQuantizationType)
236                        }
237                        "translationQuantizationType" => {
238                            Ok(__Field::m_translationQuantizationType)
239                        }
240                        "scaleQuantizationType" => Ok(__Field::m_scaleQuantizationType),
241                        "floatQuantizationType" => Ok(__Field::m_floatQuantizationType),
242                        _ => Ok(__Field::__ignore),
243                    }
244                }
245            }
246            impl<'de> _serde::Deserialize<'de> for __Field {
247                #[inline]
248                fn deserialize<__D>(
249                    __deserializer: __D,
250                ) -> core::result::Result<Self, __D::Error>
251                where
252                    __D: _serde::Deserializer<'de>,
253                {
254                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
255                }
256            }
257            struct __hkaSplineCompressedAnimationTrackCompressionParamsVisitor<'de> {
258                marker: _serde::__private::PhantomData<
259                    hkaSplineCompressedAnimationTrackCompressionParams,
260                >,
261                lifetime: _serde::__private::PhantomData<&'de ()>,
262            }
263            #[allow(clippy::match_single_binding)]
264            #[allow(clippy::reversed_empty_ranges)]
265            #[allow(clippy::single_match)]
266            impl<'de> _serde::de::Visitor<'de>
267            for __hkaSplineCompressedAnimationTrackCompressionParamsVisitor<'de> {
268                type Value = hkaSplineCompressedAnimationTrackCompressionParams;
269                fn expecting(
270                    &self,
271                    __formatter: &mut core::fmt::Formatter,
272                ) -> core::fmt::Result {
273                    core::fmt::Formatter::write_str(
274                        __formatter,
275                        "struct hkaSplineCompressedAnimationTrackCompressionParams",
276                    )
277                }
278                fn visit_struct_for_bytes<__A>(
279                    self,
280                    mut __map: __A,
281                ) -> _serde::__private::Result<Self::Value, __A::Error>
282                where
283                    __A: _serde::de::MapAccess<'de>,
284                {
285                    let __ptr = __A::class_ptr(&mut __map);
286                    let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
287                    let mut m_translationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
288                    let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
289                    let mut m_floatingTolerance: _serde::__private::Option<f32> = _serde::__private::None;
290                    let mut m_rotationDegree: _serde::__private::Option<u16> = _serde::__private::None;
291                    let mut m_translationDegree: _serde::__private::Option<u16> = _serde::__private::None;
292                    let mut m_scaleDegree: _serde::__private::Option<u16> = _serde::__private::None;
293                    let mut m_floatingDegree: _serde::__private::Option<u16> = _serde::__private::None;
294                    let mut m_rotationQuantizationType: _serde::__private::Option<
295                        RotationQuantization,
296                    > = _serde::__private::None;
297                    let mut m_translationQuantizationType: _serde::__private::Option<
298                        ScalarQuantization,
299                    > = _serde::__private::None;
300                    let mut m_scaleQuantizationType: _serde::__private::Option<
301                        ScalarQuantization,
302                    > = _serde::__private::None;
303                    let mut m_floatQuantizationType: _serde::__private::Option<
304                        ScalarQuantization,
305                    > = _serde::__private::None;
306                    for i in 0..12usize {
307                        match i {
308                            0usize => {
309                                if _serde::__private::Option::is_some(
310                                    &m_rotationTolerance,
311                                ) {
312                                    return _serde::__private::Err(
313                                        <__A::Error as _serde::de::Error>::duplicate_field(
314                                            "rotationTolerance",
315                                        ),
316                                    );
317                                }
318                                m_rotationTolerance = _serde::__private::Some(
319                                    match __A::next_value::<f32>(&mut __map) {
320                                        _serde::__private::Ok(__val) => __val,
321                                        _serde::__private::Err(__err) => {
322                                            return _serde::__private::Err(__err);
323                                        }
324                                    },
325                                );
326                            }
327                            1usize => {
328                                if _serde::__private::Option::is_some(
329                                    &m_translationTolerance,
330                                ) {
331                                    return _serde::__private::Err(
332                                        <__A::Error as _serde::de::Error>::duplicate_field(
333                                            "translationTolerance",
334                                        ),
335                                    );
336                                }
337                                m_translationTolerance = _serde::__private::Some(
338                                    match __A::next_value::<f32>(&mut __map) {
339                                        _serde::__private::Ok(__val) => __val,
340                                        _serde::__private::Err(__err) => {
341                                            return _serde::__private::Err(__err);
342                                        }
343                                    },
344                                );
345                            }
346                            2usize => {
347                                if _serde::__private::Option::is_some(&m_scaleTolerance) {
348                                    return _serde::__private::Err(
349                                        <__A::Error as _serde::de::Error>::duplicate_field(
350                                            "scaleTolerance",
351                                        ),
352                                    );
353                                }
354                                m_scaleTolerance = _serde::__private::Some(
355                                    match __A::next_value::<f32>(&mut __map) {
356                                        _serde::__private::Ok(__val) => __val,
357                                        _serde::__private::Err(__err) => {
358                                            return _serde::__private::Err(__err);
359                                        }
360                                    },
361                                );
362                            }
363                            3usize => {
364                                if _serde::__private::Option::is_some(
365                                    &m_floatingTolerance,
366                                ) {
367                                    return _serde::__private::Err(
368                                        <__A::Error as _serde::de::Error>::duplicate_field(
369                                            "floatingTolerance",
370                                        ),
371                                    );
372                                }
373                                m_floatingTolerance = _serde::__private::Some(
374                                    match __A::next_value::<f32>(&mut __map) {
375                                        _serde::__private::Ok(__val) => __val,
376                                        _serde::__private::Err(__err) => {
377                                            return _serde::__private::Err(__err);
378                                        }
379                                    },
380                                );
381                            }
382                            4usize => {
383                                if _serde::__private::Option::is_some(&m_rotationDegree) {
384                                    return _serde::__private::Err(
385                                        <__A::Error as _serde::de::Error>::duplicate_field(
386                                            "rotationDegree",
387                                        ),
388                                    );
389                                }
390                                m_rotationDegree = _serde::__private::Some(
391                                    match __A::next_value::<u16>(&mut __map) {
392                                        _serde::__private::Ok(__val) => __val,
393                                        _serde::__private::Err(__err) => {
394                                            return _serde::__private::Err(__err);
395                                        }
396                                    },
397                                );
398                            }
399                            5usize => {
400                                if _serde::__private::Option::is_some(
401                                    &m_translationDegree,
402                                ) {
403                                    return _serde::__private::Err(
404                                        <__A::Error as _serde::de::Error>::duplicate_field(
405                                            "translationDegree",
406                                        ),
407                                    );
408                                }
409                                m_translationDegree = _serde::__private::Some(
410                                    match __A::next_value::<u16>(&mut __map) {
411                                        _serde::__private::Ok(__val) => __val,
412                                        _serde::__private::Err(__err) => {
413                                            return _serde::__private::Err(__err);
414                                        }
415                                    },
416                                );
417                            }
418                            6usize => {
419                                if _serde::__private::Option::is_some(&m_scaleDegree) {
420                                    return _serde::__private::Err(
421                                        <__A::Error as _serde::de::Error>::duplicate_field(
422                                            "scaleDegree",
423                                        ),
424                                    );
425                                }
426                                m_scaleDegree = _serde::__private::Some(
427                                    match __A::next_value::<u16>(&mut __map) {
428                                        _serde::__private::Ok(__val) => __val,
429                                        _serde::__private::Err(__err) => {
430                                            return _serde::__private::Err(__err);
431                                        }
432                                    },
433                                );
434                            }
435                            7usize => {
436                                if _serde::__private::Option::is_some(&m_floatingDegree) {
437                                    return _serde::__private::Err(
438                                        <__A::Error as _serde::de::Error>::duplicate_field(
439                                            "floatingDegree",
440                                        ),
441                                    );
442                                }
443                                m_floatingDegree = _serde::__private::Some(
444                                    match __A::next_value::<u16>(&mut __map) {
445                                        _serde::__private::Ok(__val) => __val,
446                                        _serde::__private::Err(__err) => {
447                                            return _serde::__private::Err(__err);
448                                        }
449                                    },
450                                );
451                            }
452                            8usize => {
453                                if _serde::__private::Option::is_some(
454                                    &m_rotationQuantizationType,
455                                ) {
456                                    return _serde::__private::Err(
457                                        <__A::Error as _serde::de::Error>::duplicate_field(
458                                            "rotationQuantizationType",
459                                        ),
460                                    );
461                                }
462                                m_rotationQuantizationType = _serde::__private::Some(
463                                    match __A::next_value::<RotationQuantization>(&mut __map) {
464                                        _serde::__private::Ok(__val) => __val,
465                                        _serde::__private::Err(__err) => {
466                                            return _serde::__private::Err(__err);
467                                        }
468                                    },
469                                );
470                            }
471                            9usize => {
472                                if _serde::__private::Option::is_some(
473                                    &m_translationQuantizationType,
474                                ) {
475                                    return _serde::__private::Err(
476                                        <__A::Error as _serde::de::Error>::duplicate_field(
477                                            "translationQuantizationType",
478                                        ),
479                                    );
480                                }
481                                m_translationQuantizationType = _serde::__private::Some(
482                                    match __A::next_value::<ScalarQuantization>(&mut __map) {
483                                        _serde::__private::Ok(__val) => __val,
484                                        _serde::__private::Err(__err) => {
485                                            return _serde::__private::Err(__err);
486                                        }
487                                    },
488                                );
489                            }
490                            10usize => {
491                                if _serde::__private::Option::is_some(
492                                    &m_scaleQuantizationType,
493                                ) {
494                                    return _serde::__private::Err(
495                                        <__A::Error as _serde::de::Error>::duplicate_field(
496                                            "scaleQuantizationType",
497                                        ),
498                                    );
499                                }
500                                m_scaleQuantizationType = _serde::__private::Some(
501                                    match __A::next_value::<ScalarQuantization>(&mut __map) {
502                                        _serde::__private::Ok(__val) => __val,
503                                        _serde::__private::Err(__err) => {
504                                            return _serde::__private::Err(__err);
505                                        }
506                                    },
507                                );
508                            }
509                            11usize => {
510                                if _serde::__private::Option::is_some(
511                                    &m_floatQuantizationType,
512                                ) {
513                                    return _serde::__private::Err(
514                                        <__A::Error as _serde::de::Error>::duplicate_field(
515                                            "floatQuantizationType",
516                                        ),
517                                    );
518                                }
519                                m_floatQuantizationType = _serde::__private::Some(
520                                    match __A::next_value::<ScalarQuantization>(&mut __map) {
521                                        _serde::__private::Ok(__val) => __val,
522                                        _serde::__private::Err(__err) => {
523                                            return _serde::__private::Err(__err);
524                                        }
525                                    },
526                                );
527                            }
528                            _ => {}
529                        }
530                    }
531                    let m_rotationTolerance = match m_rotationTolerance {
532                        _serde::__private::Some(__field) => __field,
533                        _serde::__private::None => {
534                            return _serde::__private::Err(
535                                <__A::Error as _serde::de::Error>::missing_field(
536                                    "rotationTolerance",
537                                ),
538                            );
539                        }
540                    };
541                    let m_translationTolerance = match m_translationTolerance {
542                        _serde::__private::Some(__field) => __field,
543                        _serde::__private::None => {
544                            return _serde::__private::Err(
545                                <__A::Error as _serde::de::Error>::missing_field(
546                                    "translationTolerance",
547                                ),
548                            );
549                        }
550                    };
551                    let m_scaleTolerance = match m_scaleTolerance {
552                        _serde::__private::Some(__field) => __field,
553                        _serde::__private::None => {
554                            return _serde::__private::Err(
555                                <__A::Error as _serde::de::Error>::missing_field(
556                                    "scaleTolerance",
557                                ),
558                            );
559                        }
560                    };
561                    let m_floatingTolerance = match m_floatingTolerance {
562                        _serde::__private::Some(__field) => __field,
563                        _serde::__private::None => {
564                            return _serde::__private::Err(
565                                <__A::Error as _serde::de::Error>::missing_field(
566                                    "floatingTolerance",
567                                ),
568                            );
569                        }
570                    };
571                    let m_rotationDegree = match m_rotationDegree {
572                        _serde::__private::Some(__field) => __field,
573                        _serde::__private::None => {
574                            return _serde::__private::Err(
575                                <__A::Error as _serde::de::Error>::missing_field(
576                                    "rotationDegree",
577                                ),
578                            );
579                        }
580                    };
581                    let m_translationDegree = match m_translationDegree {
582                        _serde::__private::Some(__field) => __field,
583                        _serde::__private::None => {
584                            return _serde::__private::Err(
585                                <__A::Error as _serde::de::Error>::missing_field(
586                                    "translationDegree",
587                                ),
588                            );
589                        }
590                    };
591                    let m_scaleDegree = match m_scaleDegree {
592                        _serde::__private::Some(__field) => __field,
593                        _serde::__private::None => {
594                            return _serde::__private::Err(
595                                <__A::Error as _serde::de::Error>::missing_field(
596                                    "scaleDegree",
597                                ),
598                            );
599                        }
600                    };
601                    let m_floatingDegree = match m_floatingDegree {
602                        _serde::__private::Some(__field) => __field,
603                        _serde::__private::None => {
604                            return _serde::__private::Err(
605                                <__A::Error as _serde::de::Error>::missing_field(
606                                    "floatingDegree",
607                                ),
608                            );
609                        }
610                    };
611                    let m_rotationQuantizationType = match m_rotationQuantizationType {
612                        _serde::__private::Some(__field) => __field,
613                        _serde::__private::None => {
614                            return _serde::__private::Err(
615                                <__A::Error as _serde::de::Error>::missing_field(
616                                    "rotationQuantizationType",
617                                ),
618                            );
619                        }
620                    };
621                    let m_translationQuantizationType = match m_translationQuantizationType {
622                        _serde::__private::Some(__field) => __field,
623                        _serde::__private::None => {
624                            return _serde::__private::Err(
625                                <__A::Error as _serde::de::Error>::missing_field(
626                                    "translationQuantizationType",
627                                ),
628                            );
629                        }
630                    };
631                    let m_scaleQuantizationType = match m_scaleQuantizationType {
632                        _serde::__private::Some(__field) => __field,
633                        _serde::__private::None => {
634                            return _serde::__private::Err(
635                                <__A::Error as _serde::de::Error>::missing_field(
636                                    "scaleQuantizationType",
637                                ),
638                            );
639                        }
640                    };
641                    let m_floatQuantizationType = match m_floatQuantizationType {
642                        _serde::__private::Some(__field) => __field,
643                        _serde::__private::None => {
644                            return _serde::__private::Err(
645                                <__A::Error as _serde::de::Error>::missing_field(
646                                    "floatQuantizationType",
647                                ),
648                            );
649                        }
650                    };
651                    _serde::__private::Ok(hkaSplineCompressedAnimationTrackCompressionParams {
652                        __ptr,
653                        m_rotationTolerance,
654                        m_translationTolerance,
655                        m_scaleTolerance,
656                        m_floatingTolerance,
657                        m_rotationDegree,
658                        m_translationDegree,
659                        m_scaleDegree,
660                        m_floatingDegree,
661                        m_rotationQuantizationType,
662                        m_translationQuantizationType,
663                        m_scaleQuantizationType,
664                        m_floatQuantizationType,
665                    })
666                }
667                #[allow(clippy::manual_unwrap_or_default)]
668                fn visit_struct<__A>(
669                    self,
670                    mut __map: __A,
671                ) -> _serde::__private::Result<Self::Value, __A::Error>
672                where
673                    __A: _serde::de::MapAccess<'de>,
674                {
675                    let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
676                    let mut m_translationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
677                    let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
678                    let mut m_floatingTolerance: _serde::__private::Option<f32> = _serde::__private::None;
679                    let mut m_rotationDegree: _serde::__private::Option<u16> = _serde::__private::None;
680                    let mut m_translationDegree: _serde::__private::Option<u16> = _serde::__private::None;
681                    let mut m_scaleDegree: _serde::__private::Option<u16> = _serde::__private::None;
682                    let mut m_floatingDegree: _serde::__private::Option<u16> = _serde::__private::None;
683                    let mut m_rotationQuantizationType: _serde::__private::Option<
684                        RotationQuantization,
685                    > = _serde::__private::None;
686                    let mut m_translationQuantizationType: _serde::__private::Option<
687                        ScalarQuantization,
688                    > = _serde::__private::None;
689                    let mut m_scaleQuantizationType: _serde::__private::Option<
690                        ScalarQuantization,
691                    > = _serde::__private::None;
692                    let mut m_floatQuantizationType: _serde::__private::Option<
693                        ScalarQuantization,
694                    > = _serde::__private::None;
695                    while let _serde::__private::Some(__key) = {
696                        __A::next_key::<__Field>(&mut __map)?
697                    } {
698                        match __key {
699                            __Field::m_rotationTolerance => {
700                                #[cfg(
701                                    any(feature = "strict", feature = "ignore_duplicates")
702                                )]
703                                if _serde::__private::Option::is_some(
704                                    &m_rotationTolerance,
705                                ) {
706                                    #[cfg(feature = "ignore_duplicates")]
707                                    {
708                                        __A::skip_value(&mut __map)?;
709                                        continue;
710                                    }
711                                    #[cfg(feature = "strict")]
712                                    return _serde::__private::Err(
713                                        <__A::Error as _serde::de::Error>::duplicate_field(
714                                            "rotationTolerance",
715                                        ),
716                                    );
717                                }
718                                m_rotationTolerance = _serde::__private::Some(
719                                    match __A::next_value::<f32>(&mut __map) {
720                                        _serde::__private::Ok(__val) => __val,
721                                        _serde::__private::Err(__err) => {
722                                            return _serde::__private::Err(__err);
723                                        }
724                                    },
725                                );
726                            }
727                            __Field::m_translationTolerance => {
728                                #[cfg(
729                                    any(feature = "strict", feature = "ignore_duplicates")
730                                )]
731                                if _serde::__private::Option::is_some(
732                                    &m_translationTolerance,
733                                ) {
734                                    #[cfg(feature = "ignore_duplicates")]
735                                    {
736                                        __A::skip_value(&mut __map)?;
737                                        continue;
738                                    }
739                                    #[cfg(feature = "strict")]
740                                    return _serde::__private::Err(
741                                        <__A::Error as _serde::de::Error>::duplicate_field(
742                                            "translationTolerance",
743                                        ),
744                                    );
745                                }
746                                m_translationTolerance = _serde::__private::Some(
747                                    match __A::next_value::<f32>(&mut __map) {
748                                        _serde::__private::Ok(__val) => __val,
749                                        _serde::__private::Err(__err) => {
750                                            return _serde::__private::Err(__err);
751                                        }
752                                    },
753                                );
754                            }
755                            __Field::m_scaleTolerance => {
756                                #[cfg(
757                                    any(feature = "strict", feature = "ignore_duplicates")
758                                )]
759                                if _serde::__private::Option::is_some(&m_scaleTolerance) {
760                                    #[cfg(feature = "ignore_duplicates")]
761                                    {
762                                        __A::skip_value(&mut __map)?;
763                                        continue;
764                                    }
765                                    #[cfg(feature = "strict")]
766                                    return _serde::__private::Err(
767                                        <__A::Error as _serde::de::Error>::duplicate_field(
768                                            "scaleTolerance",
769                                        ),
770                                    );
771                                }
772                                m_scaleTolerance = _serde::__private::Some(
773                                    match __A::next_value::<f32>(&mut __map) {
774                                        _serde::__private::Ok(__val) => __val,
775                                        _serde::__private::Err(__err) => {
776                                            return _serde::__private::Err(__err);
777                                        }
778                                    },
779                                );
780                            }
781                            __Field::m_floatingTolerance => {
782                                #[cfg(
783                                    any(feature = "strict", feature = "ignore_duplicates")
784                                )]
785                                if _serde::__private::Option::is_some(
786                                    &m_floatingTolerance,
787                                ) {
788                                    #[cfg(feature = "ignore_duplicates")]
789                                    {
790                                        __A::skip_value(&mut __map)?;
791                                        continue;
792                                    }
793                                    #[cfg(feature = "strict")]
794                                    return _serde::__private::Err(
795                                        <__A::Error as _serde::de::Error>::duplicate_field(
796                                            "floatingTolerance",
797                                        ),
798                                    );
799                                }
800                                m_floatingTolerance = _serde::__private::Some(
801                                    match __A::next_value::<f32>(&mut __map) {
802                                        _serde::__private::Ok(__val) => __val,
803                                        _serde::__private::Err(__err) => {
804                                            return _serde::__private::Err(__err);
805                                        }
806                                    },
807                                );
808                            }
809                            __Field::m_rotationDegree => {
810                                #[cfg(
811                                    any(feature = "strict", feature = "ignore_duplicates")
812                                )]
813                                if _serde::__private::Option::is_some(&m_rotationDegree) {
814                                    #[cfg(feature = "ignore_duplicates")]
815                                    {
816                                        __A::skip_value(&mut __map)?;
817                                        continue;
818                                    }
819                                    #[cfg(feature = "strict")]
820                                    return _serde::__private::Err(
821                                        <__A::Error as _serde::de::Error>::duplicate_field(
822                                            "rotationDegree",
823                                        ),
824                                    );
825                                }
826                                m_rotationDegree = _serde::__private::Some(
827                                    match __A::next_value::<u16>(&mut __map) {
828                                        _serde::__private::Ok(__val) => __val,
829                                        _serde::__private::Err(__err) => {
830                                            return _serde::__private::Err(__err);
831                                        }
832                                    },
833                                );
834                            }
835                            __Field::m_translationDegree => {
836                                #[cfg(
837                                    any(feature = "strict", feature = "ignore_duplicates")
838                                )]
839                                if _serde::__private::Option::is_some(
840                                    &m_translationDegree,
841                                ) {
842                                    #[cfg(feature = "ignore_duplicates")]
843                                    {
844                                        __A::skip_value(&mut __map)?;
845                                        continue;
846                                    }
847                                    #[cfg(feature = "strict")]
848                                    return _serde::__private::Err(
849                                        <__A::Error as _serde::de::Error>::duplicate_field(
850                                            "translationDegree",
851                                        ),
852                                    );
853                                }
854                                m_translationDegree = _serde::__private::Some(
855                                    match __A::next_value::<u16>(&mut __map) {
856                                        _serde::__private::Ok(__val) => __val,
857                                        _serde::__private::Err(__err) => {
858                                            return _serde::__private::Err(__err);
859                                        }
860                                    },
861                                );
862                            }
863                            __Field::m_scaleDegree => {
864                                #[cfg(
865                                    any(feature = "strict", feature = "ignore_duplicates")
866                                )]
867                                if _serde::__private::Option::is_some(&m_scaleDegree) {
868                                    #[cfg(feature = "ignore_duplicates")]
869                                    {
870                                        __A::skip_value(&mut __map)?;
871                                        continue;
872                                    }
873                                    #[cfg(feature = "strict")]
874                                    return _serde::__private::Err(
875                                        <__A::Error as _serde::de::Error>::duplicate_field(
876                                            "scaleDegree",
877                                        ),
878                                    );
879                                }
880                                m_scaleDegree = _serde::__private::Some(
881                                    match __A::next_value::<u16>(&mut __map) {
882                                        _serde::__private::Ok(__val) => __val,
883                                        _serde::__private::Err(__err) => {
884                                            return _serde::__private::Err(__err);
885                                        }
886                                    },
887                                );
888                            }
889                            __Field::m_floatingDegree => {
890                                #[cfg(
891                                    any(feature = "strict", feature = "ignore_duplicates")
892                                )]
893                                if _serde::__private::Option::is_some(&m_floatingDegree) {
894                                    #[cfg(feature = "ignore_duplicates")]
895                                    {
896                                        __A::skip_value(&mut __map)?;
897                                        continue;
898                                    }
899                                    #[cfg(feature = "strict")]
900                                    return _serde::__private::Err(
901                                        <__A::Error as _serde::de::Error>::duplicate_field(
902                                            "floatingDegree",
903                                        ),
904                                    );
905                                }
906                                m_floatingDegree = _serde::__private::Some(
907                                    match __A::next_value::<u16>(&mut __map) {
908                                        _serde::__private::Ok(__val) => __val,
909                                        _serde::__private::Err(__err) => {
910                                            return _serde::__private::Err(__err);
911                                        }
912                                    },
913                                );
914                            }
915                            __Field::m_rotationQuantizationType => {
916                                #[cfg(
917                                    any(feature = "strict", feature = "ignore_duplicates")
918                                )]
919                                if _serde::__private::Option::is_some(
920                                    &m_rotationQuantizationType,
921                                ) {
922                                    #[cfg(feature = "ignore_duplicates")]
923                                    {
924                                        __A::skip_value(&mut __map)?;
925                                        continue;
926                                    }
927                                    #[cfg(feature = "strict")]
928                                    return _serde::__private::Err(
929                                        <__A::Error as _serde::de::Error>::duplicate_field(
930                                            "rotationQuantizationType",
931                                        ),
932                                    );
933                                }
934                                m_rotationQuantizationType = _serde::__private::Some(
935                                    match __A::next_value::<RotationQuantization>(&mut __map) {
936                                        _serde::__private::Ok(__val) => __val,
937                                        _serde::__private::Err(__err) => {
938                                            return _serde::__private::Err(__err);
939                                        }
940                                    },
941                                );
942                            }
943                            __Field::m_translationQuantizationType => {
944                                #[cfg(
945                                    any(feature = "strict", feature = "ignore_duplicates")
946                                )]
947                                if _serde::__private::Option::is_some(
948                                    &m_translationQuantizationType,
949                                ) {
950                                    #[cfg(feature = "ignore_duplicates")]
951                                    {
952                                        __A::skip_value(&mut __map)?;
953                                        continue;
954                                    }
955                                    #[cfg(feature = "strict")]
956                                    return _serde::__private::Err(
957                                        <__A::Error as _serde::de::Error>::duplicate_field(
958                                            "translationQuantizationType",
959                                        ),
960                                    );
961                                }
962                                m_translationQuantizationType = _serde::__private::Some(
963                                    match __A::next_value::<ScalarQuantization>(&mut __map) {
964                                        _serde::__private::Ok(__val) => __val,
965                                        _serde::__private::Err(__err) => {
966                                            return _serde::__private::Err(__err);
967                                        }
968                                    },
969                                );
970                            }
971                            __Field::m_scaleQuantizationType => {
972                                #[cfg(
973                                    any(feature = "strict", feature = "ignore_duplicates")
974                                )]
975                                if _serde::__private::Option::is_some(
976                                    &m_scaleQuantizationType,
977                                ) {
978                                    #[cfg(feature = "ignore_duplicates")]
979                                    {
980                                        __A::skip_value(&mut __map)?;
981                                        continue;
982                                    }
983                                    #[cfg(feature = "strict")]
984                                    return _serde::__private::Err(
985                                        <__A::Error as _serde::de::Error>::duplicate_field(
986                                            "scaleQuantizationType",
987                                        ),
988                                    );
989                                }
990                                m_scaleQuantizationType = _serde::__private::Some(
991                                    match __A::next_value::<ScalarQuantization>(&mut __map) {
992                                        _serde::__private::Ok(__val) => __val,
993                                        _serde::__private::Err(__err) => {
994                                            return _serde::__private::Err(__err);
995                                        }
996                                    },
997                                );
998                            }
999                            __Field::m_floatQuantizationType => {
1000                                #[cfg(
1001                                    any(feature = "strict", feature = "ignore_duplicates")
1002                                )]
1003                                if _serde::__private::Option::is_some(
1004                                    &m_floatQuantizationType,
1005                                ) {
1006                                    #[cfg(feature = "ignore_duplicates")]
1007                                    {
1008                                        __A::skip_value(&mut __map)?;
1009                                        continue;
1010                                    }
1011                                    #[cfg(feature = "strict")]
1012                                    return _serde::__private::Err(
1013                                        <__A::Error as _serde::de::Error>::duplicate_field(
1014                                            "floatQuantizationType",
1015                                        ),
1016                                    );
1017                                }
1018                                m_floatQuantizationType = _serde::__private::Some(
1019                                    match __A::next_value::<ScalarQuantization>(&mut __map) {
1020                                        _serde::__private::Ok(__val) => __val,
1021                                        _serde::__private::Err(__err) => {
1022                                            return _serde::__private::Err(__err);
1023                                        }
1024                                    },
1025                                );
1026                            }
1027                            _ => __A::skip_value(&mut __map)?,
1028                        }
1029                    }
1030                    let m_rotationTolerance = match m_rotationTolerance {
1031                        _serde::__private::Some(__field) => __field,
1032                        _serde::__private::None => {
1033                            #[cfg(feature = "strict")]
1034                            return _serde::__private::Err(
1035                                <__A::Error as _serde::de::Error>::missing_field(
1036                                    "rotationTolerance",
1037                                ),
1038                            );
1039                            #[cfg(not(feature = "strict"))] Default::default()
1040                        }
1041                    };
1042                    let m_translationTolerance = match m_translationTolerance {
1043                        _serde::__private::Some(__field) => __field,
1044                        _serde::__private::None => {
1045                            #[cfg(feature = "strict")]
1046                            return _serde::__private::Err(
1047                                <__A::Error as _serde::de::Error>::missing_field(
1048                                    "translationTolerance",
1049                                ),
1050                            );
1051                            #[cfg(not(feature = "strict"))] Default::default()
1052                        }
1053                    };
1054                    let m_scaleTolerance = match m_scaleTolerance {
1055                        _serde::__private::Some(__field) => __field,
1056                        _serde::__private::None => {
1057                            #[cfg(feature = "strict")]
1058                            return _serde::__private::Err(
1059                                <__A::Error as _serde::de::Error>::missing_field(
1060                                    "scaleTolerance",
1061                                ),
1062                            );
1063                            #[cfg(not(feature = "strict"))] Default::default()
1064                        }
1065                    };
1066                    let m_floatingTolerance = match m_floatingTolerance {
1067                        _serde::__private::Some(__field) => __field,
1068                        _serde::__private::None => {
1069                            #[cfg(feature = "strict")]
1070                            return _serde::__private::Err(
1071                                <__A::Error as _serde::de::Error>::missing_field(
1072                                    "floatingTolerance",
1073                                ),
1074                            );
1075                            #[cfg(not(feature = "strict"))] Default::default()
1076                        }
1077                    };
1078                    let m_rotationDegree = match m_rotationDegree {
1079                        _serde::__private::Some(__field) => __field,
1080                        _serde::__private::None => {
1081                            #[cfg(feature = "strict")]
1082                            return _serde::__private::Err(
1083                                <__A::Error as _serde::de::Error>::missing_field(
1084                                    "rotationDegree",
1085                                ),
1086                            );
1087                            #[cfg(not(feature = "strict"))] Default::default()
1088                        }
1089                    };
1090                    let m_translationDegree = match m_translationDegree {
1091                        _serde::__private::Some(__field) => __field,
1092                        _serde::__private::None => {
1093                            #[cfg(feature = "strict")]
1094                            return _serde::__private::Err(
1095                                <__A::Error as _serde::de::Error>::missing_field(
1096                                    "translationDegree",
1097                                ),
1098                            );
1099                            #[cfg(not(feature = "strict"))] Default::default()
1100                        }
1101                    };
1102                    let m_scaleDegree = match m_scaleDegree {
1103                        _serde::__private::Some(__field) => __field,
1104                        _serde::__private::None => {
1105                            #[cfg(feature = "strict")]
1106                            return _serde::__private::Err(
1107                                <__A::Error as _serde::de::Error>::missing_field(
1108                                    "scaleDegree",
1109                                ),
1110                            );
1111                            #[cfg(not(feature = "strict"))] Default::default()
1112                        }
1113                    };
1114                    let m_floatingDegree = match m_floatingDegree {
1115                        _serde::__private::Some(__field) => __field,
1116                        _serde::__private::None => {
1117                            #[cfg(feature = "strict")]
1118                            return _serde::__private::Err(
1119                                <__A::Error as _serde::de::Error>::missing_field(
1120                                    "floatingDegree",
1121                                ),
1122                            );
1123                            #[cfg(not(feature = "strict"))] Default::default()
1124                        }
1125                    };
1126                    let m_rotationQuantizationType = match m_rotationQuantizationType {
1127                        _serde::__private::Some(__field) => __field,
1128                        _serde::__private::None => {
1129                            #[cfg(feature = "strict")]
1130                            return _serde::__private::Err(
1131                                <__A::Error as _serde::de::Error>::missing_field(
1132                                    "rotationQuantizationType",
1133                                ),
1134                            );
1135                            #[cfg(not(feature = "strict"))] Default::default()
1136                        }
1137                    };
1138                    let m_translationQuantizationType = match m_translationQuantizationType {
1139                        _serde::__private::Some(__field) => __field,
1140                        _serde::__private::None => {
1141                            #[cfg(feature = "strict")]
1142                            return _serde::__private::Err(
1143                                <__A::Error as _serde::de::Error>::missing_field(
1144                                    "translationQuantizationType",
1145                                ),
1146                            );
1147                            #[cfg(not(feature = "strict"))] Default::default()
1148                        }
1149                    };
1150                    let m_scaleQuantizationType = match m_scaleQuantizationType {
1151                        _serde::__private::Some(__field) => __field,
1152                        _serde::__private::None => {
1153                            #[cfg(feature = "strict")]
1154                            return _serde::__private::Err(
1155                                <__A::Error as _serde::de::Error>::missing_field(
1156                                    "scaleQuantizationType",
1157                                ),
1158                            );
1159                            #[cfg(not(feature = "strict"))] Default::default()
1160                        }
1161                    };
1162                    let m_floatQuantizationType = match m_floatQuantizationType {
1163                        _serde::__private::Some(__field) => __field,
1164                        _serde::__private::None => {
1165                            #[cfg(feature = "strict")]
1166                            return _serde::__private::Err(
1167                                <__A::Error as _serde::de::Error>::missing_field(
1168                                    "floatQuantizationType",
1169                                ),
1170                            );
1171                            #[cfg(not(feature = "strict"))] Default::default()
1172                        }
1173                    };
1174                    let __ptr = __A::class_ptr(&mut __map);
1175                    _serde::__private::Ok(hkaSplineCompressedAnimationTrackCompressionParams {
1176                        __ptr,
1177                        m_rotationTolerance,
1178                        m_translationTolerance,
1179                        m_scaleTolerance,
1180                        m_floatingTolerance,
1181                        m_rotationDegree,
1182                        m_translationDegree,
1183                        m_scaleDegree,
1184                        m_floatingDegree,
1185                        m_rotationQuantizationType,
1186                        m_translationQuantizationType,
1187                        m_scaleQuantizationType,
1188                        m_floatQuantizationType,
1189                    })
1190                }
1191            }
1192            const FIELDS: &[&str] = &[
1193                "rotationTolerance",
1194                "translationTolerance",
1195                "scaleTolerance",
1196                "floatingTolerance",
1197                "rotationDegree",
1198                "translationDegree",
1199                "scaleDegree",
1200                "floatingDegree",
1201                "rotationQuantizationType",
1202                "translationQuantizationType",
1203                "scaleQuantizationType",
1204                "floatQuantizationType",
1205            ];
1206            _serde::Deserializer::deserialize_struct(
1207                deserializer,
1208                "hkaSplineCompressedAnimationTrackCompressionParams",
1209                FIELDS,
1210                __hkaSplineCompressedAnimationTrackCompressionParamsVisitor {
1211                    marker: _serde::__private::PhantomData::<
1212                        hkaSplineCompressedAnimationTrackCompressionParams,
1213                    >,
1214                    lifetime: _serde::__private::PhantomData,
1215                },
1216            )
1217        }
1218    }
1219};
1220/// # C++ Info
1221/// - name: `RotationQuantization`(ctype: `hkEnum<RotationQuantization, hkUint8>`)
1222#[allow(non_upper_case_globals, non_snake_case)]
1223#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1224#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1225#[derive(
1226    Debug,
1227    Clone,
1228    Default,
1229    PartialEq,
1230    Eq,
1231    PartialOrd,
1232    Ord,
1233    num_derive::ToPrimitive,
1234    num_derive::FromPrimitive,
1235)]
1236pub enum RotationQuantization {
1237    #[default]
1238    POLAR32 = 0isize,
1239    THREECOMP40 = 1isize,
1240    THREECOMP48 = 2isize,
1241    THREECOMP24 = 3isize,
1242    STRAIGHT16 = 4isize,
1243    UNCOMPRESSED = 5isize,
1244}
1245/// # C++ Info
1246/// - name: `ScalarQuantization`(ctype: `hkEnum<ScalarQuantization, hkUint8>`)
1247#[allow(non_upper_case_globals, non_snake_case)]
1248#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1249#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1250#[derive(
1251    Debug,
1252    Clone,
1253    Default,
1254    PartialEq,
1255    Eq,
1256    PartialOrd,
1257    Ord,
1258    num_derive::ToPrimitive,
1259    num_derive::FromPrimitive,
1260)]
1261pub enum ScalarQuantization {
1262    #[default]
1263    BITS8 = 0isize,
1264    BITS16 = 1isize,
1265}
1266const _: () = {
1267    use havok_serde as __serde;
1268    impl __serde::Serialize for RotationQuantization {
1269        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1270        where
1271            S: __serde::ser::Serializer,
1272        {
1273            let mut __serializer = __serializer.serialize_enum_flags()?;
1274            match self {
1275                Self::POLAR32 => __serializer.serialize_field("POLAR32", &0u64),
1276                Self::THREECOMP40 => __serializer.serialize_field("THREECOMP40", &1u64),
1277                Self::THREECOMP48 => __serializer.serialize_field("THREECOMP48", &2u64),
1278                Self::THREECOMP24 => __serializer.serialize_field("THREECOMP24", &3u64),
1279                Self::STRAIGHT16 => __serializer.serialize_field("STRAIGHT16", &4u64),
1280                Self::UNCOMPRESSED => __serializer.serialize_field("UNCOMPRESSED", &5u64),
1281            }?;
1282            use num_traits::ToPrimitive as _;
1283            let num = self
1284                .to_u8()
1285                .ok_or(S::Error::custom("Failed enum RotationQuantization to_u8"))?;
1286            __serializer.serialize_bits(&num)?;
1287            __serializer.end()
1288        }
1289    }
1290};
1291const _: () = {
1292    use havok_serde as __serde;
1293    impl __serde::Serialize for ScalarQuantization {
1294        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1295        where
1296            S: __serde::ser::Serializer,
1297        {
1298            let mut __serializer = __serializer.serialize_enum_flags()?;
1299            match self {
1300                Self::BITS8 => __serializer.serialize_field("BITS8", &0u64),
1301                Self::BITS16 => __serializer.serialize_field("BITS16", &1u64),
1302            }?;
1303            use num_traits::ToPrimitive as _;
1304            let num = self
1305                .to_u8()
1306                .ok_or(S::Error::custom("Failed enum ScalarQuantization to_u8"))?;
1307            __serializer.serialize_bits(&num)?;
1308            __serializer.end()
1309        }
1310    }
1311};
1312#[doc(hidden)]
1313#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1314const _: () = {
1315    #[allow(unused_extern_crates, clippy::useless_attribute)]
1316    extern crate havok_serde as _serde;
1317    #[automatically_derived]
1318    impl<'de> _serde::Deserialize<'de> for RotationQuantization {
1319        fn deserialize<__D>(
1320            __deserializer: __D,
1321        ) -> _serde::__private::Result<Self, __D::Error>
1322        where
1323            __D: _serde::Deserializer<'de>,
1324        {
1325            #[allow(non_camel_case_types)]
1326            #[doc(hidden)]
1327            enum __Field {
1328                __field0,
1329                __field1,
1330                __field2,
1331                __field3,
1332                __field4,
1333                __field5,
1334            }
1335            #[doc(hidden)]
1336            struct __FieldVisitor;
1337            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1338                type Value = __Field;
1339                fn expecting(
1340                    &self,
1341                    __formatter: &mut _serde::__private::Formatter,
1342                ) -> _serde::__private::fmt::Result {
1343                    _serde::__private::Formatter::write_str(
1344                        __formatter,
1345                        "variant identifier",
1346                    )
1347                }
1348                fn visit_uint8<__E>(
1349                    self,
1350                    __value: u8,
1351                ) -> _serde::__private::Result<Self::Value, __E>
1352                where
1353                    __E: _serde::de::Error,
1354                {
1355                    match __value {
1356                        0u8 => _serde::__private::Ok(__Field::__field0),
1357                        1u8 => _serde::__private::Ok(__Field::__field1),
1358                        2u8 => _serde::__private::Ok(__Field::__field2),
1359                        3u8 => _serde::__private::Ok(__Field::__field3),
1360                        4u8 => _serde::__private::Ok(__Field::__field4),
1361                        5u8 => _serde::__private::Ok(__Field::__field5),
1362                        _ => {
1363                            _serde::__private::Err(
1364                                _serde::de::Error::invalid_value(
1365                                    _serde::de::Unexpected::Uint8(__value),
1366                                    &"value(u8) of variant is one of 0, 1, 2, 3, 4, 5",
1367                                ),
1368                            )
1369                        }
1370                    }
1371                }
1372                fn visit_stringptr<__E>(
1373                    self,
1374                    __value: StringPtr<'de>,
1375                ) -> _serde::__private::Result<Self::Value, __E>
1376                where
1377                    __E: _serde::de::Error,
1378                {
1379                    if let Some(__value) = __value.into_inner() {
1380                        match __value.as_ref() {
1381                            v if v == "0" || v.eq_ignore_ascii_case("POLAR32") => {
1382                                _serde::__private::Ok(__Field::__field0)
1383                            }
1384                            v if v == "1" || v.eq_ignore_ascii_case("THREECOMP40") => {
1385                                _serde::__private::Ok(__Field::__field1)
1386                            }
1387                            v if v == "2" || v.eq_ignore_ascii_case("THREECOMP48") => {
1388                                _serde::__private::Ok(__Field::__field2)
1389                            }
1390                            v if v == "3" || v.eq_ignore_ascii_case("THREECOMP24") => {
1391                                _serde::__private::Ok(__Field::__field3)
1392                            }
1393                            v if v == "4" || v.eq_ignore_ascii_case("STRAIGHT16") => {
1394                                _serde::__private::Ok(__Field::__field4)
1395                            }
1396                            v if v == "5" || v.eq_ignore_ascii_case("UNCOMPRESSED") => {
1397                                _serde::__private::Ok(__Field::__field5)
1398                            }
1399                            _ => {
1400                                _serde::__private::Err(
1401                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1402                                )
1403                            }
1404                        }
1405                    } else {
1406                        _serde::__private::Err(
1407                            _serde::de::Error::unknown_variant("None", VARIANTS),
1408                        )
1409                    }
1410                }
1411            }
1412            impl<'de> _serde::Deserialize<'de> for __Field {
1413                #[inline]
1414                fn deserialize<__D>(
1415                    __deserializer: __D,
1416                ) -> _serde::__private::Result<Self, __D::Error>
1417                where
1418                    __D: _serde::Deserializer<'de>,
1419                {
1420                    _serde::Deserializer::deserialize_identifier(
1421                        __deserializer,
1422                        _serde::de::ReadEnumSize::Uint8,
1423                        __FieldVisitor,
1424                    )
1425                }
1426            }
1427            #[doc(hidden)]
1428            struct __Visitor<'de> {
1429                marker: _serde::__private::PhantomData<RotationQuantization>,
1430                lifetime: _serde::__private::PhantomData<&'de ()>,
1431            }
1432            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1433                type Value = RotationQuantization;
1434                fn expecting(
1435                    &self,
1436                    __formatter: &mut _serde::__private::Formatter,
1437                ) -> _serde::__private::fmt::Result {
1438                    _serde::__private::Formatter::write_str(
1439                        __formatter,
1440                        "enum RotationQuantization",
1441                    )
1442                }
1443                fn visit_enum<__A>(
1444                    self,
1445                    __data: __A,
1446                ) -> _serde::__private::Result<Self::Value, __A::Error>
1447                where
1448                    __A: _serde::de::EnumAccess<'de>,
1449                {
1450                    match _serde::de::EnumAccess::variant(__data)? {
1451                        (__Field::__field0, __variant) => {
1452                            _serde::de::VariantAccess::unit_variant(__variant)?;
1453                            _serde::__private::Ok(RotationQuantization::POLAR32)
1454                        }
1455                        (__Field::__field1, __variant) => {
1456                            _serde::de::VariantAccess::unit_variant(__variant)?;
1457                            _serde::__private::Ok(RotationQuantization::THREECOMP40)
1458                        }
1459                        (__Field::__field2, __variant) => {
1460                            _serde::de::VariantAccess::unit_variant(__variant)?;
1461                            _serde::__private::Ok(RotationQuantization::THREECOMP48)
1462                        }
1463                        (__Field::__field3, __variant) => {
1464                            _serde::de::VariantAccess::unit_variant(__variant)?;
1465                            _serde::__private::Ok(RotationQuantization::THREECOMP24)
1466                        }
1467                        (__Field::__field4, __variant) => {
1468                            _serde::de::VariantAccess::unit_variant(__variant)?;
1469                            _serde::__private::Ok(RotationQuantization::STRAIGHT16)
1470                        }
1471                        (__Field::__field5, __variant) => {
1472                            _serde::de::VariantAccess::unit_variant(__variant)?;
1473                            _serde::__private::Ok(RotationQuantization::UNCOMPRESSED)
1474                        }
1475                    }
1476                }
1477            }
1478            #[doc(hidden)]
1479            const VARIANTS: &'static [&'static str] = &[
1480                "POLAR32",
1481                "THREECOMP40",
1482                "THREECOMP48",
1483                "THREECOMP24",
1484                "STRAIGHT16",
1485                "UNCOMPRESSED",
1486            ];
1487            _serde::Deserializer::deserialize_enum(
1488                __deserializer,
1489                "RotationQuantization",
1490                VARIANTS,
1491                __Visitor {
1492                    marker: _serde::__private::PhantomData::<RotationQuantization>,
1493                    lifetime: _serde::__private::PhantomData,
1494                },
1495            )
1496        }
1497    }
1498};
1499#[doc(hidden)]
1500#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1501const _: () = {
1502    #[allow(unused_extern_crates, clippy::useless_attribute)]
1503    extern crate havok_serde as _serde;
1504    #[automatically_derived]
1505    impl<'de> _serde::Deserialize<'de> for ScalarQuantization {
1506        fn deserialize<__D>(
1507            __deserializer: __D,
1508        ) -> _serde::__private::Result<Self, __D::Error>
1509        where
1510            __D: _serde::Deserializer<'de>,
1511        {
1512            #[allow(non_camel_case_types)]
1513            #[doc(hidden)]
1514            enum __Field {
1515                __field0,
1516                __field1,
1517            }
1518            #[doc(hidden)]
1519            struct __FieldVisitor;
1520            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1521                type Value = __Field;
1522                fn expecting(
1523                    &self,
1524                    __formatter: &mut _serde::__private::Formatter,
1525                ) -> _serde::__private::fmt::Result {
1526                    _serde::__private::Formatter::write_str(
1527                        __formatter,
1528                        "variant identifier",
1529                    )
1530                }
1531                fn visit_uint8<__E>(
1532                    self,
1533                    __value: u8,
1534                ) -> _serde::__private::Result<Self::Value, __E>
1535                where
1536                    __E: _serde::de::Error,
1537                {
1538                    match __value {
1539                        0u8 => _serde::__private::Ok(__Field::__field0),
1540                        1u8 => _serde::__private::Ok(__Field::__field1),
1541                        _ => {
1542                            _serde::__private::Err(
1543                                _serde::de::Error::invalid_value(
1544                                    _serde::de::Unexpected::Uint8(__value),
1545                                    &"value(u8) of variant is one of 0, 1",
1546                                ),
1547                            )
1548                        }
1549                    }
1550                }
1551                fn visit_stringptr<__E>(
1552                    self,
1553                    __value: StringPtr<'de>,
1554                ) -> _serde::__private::Result<Self::Value, __E>
1555                where
1556                    __E: _serde::de::Error,
1557                {
1558                    if let Some(__value) = __value.into_inner() {
1559                        match __value.as_ref() {
1560                            v if v == "0" || v.eq_ignore_ascii_case("BITS8") => {
1561                                _serde::__private::Ok(__Field::__field0)
1562                            }
1563                            v if v == "1" || v.eq_ignore_ascii_case("BITS16") => {
1564                                _serde::__private::Ok(__Field::__field1)
1565                            }
1566                            _ => {
1567                                _serde::__private::Err(
1568                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1569                                )
1570                            }
1571                        }
1572                    } else {
1573                        _serde::__private::Err(
1574                            _serde::de::Error::unknown_variant("None", VARIANTS),
1575                        )
1576                    }
1577                }
1578            }
1579            impl<'de> _serde::Deserialize<'de> for __Field {
1580                #[inline]
1581                fn deserialize<__D>(
1582                    __deserializer: __D,
1583                ) -> _serde::__private::Result<Self, __D::Error>
1584                where
1585                    __D: _serde::Deserializer<'de>,
1586                {
1587                    _serde::Deserializer::deserialize_identifier(
1588                        __deserializer,
1589                        _serde::de::ReadEnumSize::Uint8,
1590                        __FieldVisitor,
1591                    )
1592                }
1593            }
1594            #[doc(hidden)]
1595            struct __Visitor<'de> {
1596                marker: _serde::__private::PhantomData<ScalarQuantization>,
1597                lifetime: _serde::__private::PhantomData<&'de ()>,
1598            }
1599            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1600                type Value = ScalarQuantization;
1601                fn expecting(
1602                    &self,
1603                    __formatter: &mut _serde::__private::Formatter,
1604                ) -> _serde::__private::fmt::Result {
1605                    _serde::__private::Formatter::write_str(
1606                        __formatter,
1607                        "enum ScalarQuantization",
1608                    )
1609                }
1610                fn visit_enum<__A>(
1611                    self,
1612                    __data: __A,
1613                ) -> _serde::__private::Result<Self::Value, __A::Error>
1614                where
1615                    __A: _serde::de::EnumAccess<'de>,
1616                {
1617                    match _serde::de::EnumAccess::variant(__data)? {
1618                        (__Field::__field0, __variant) => {
1619                            _serde::de::VariantAccess::unit_variant(__variant)?;
1620                            _serde::__private::Ok(ScalarQuantization::BITS8)
1621                        }
1622                        (__Field::__field1, __variant) => {
1623                            _serde::de::VariantAccess::unit_variant(__variant)?;
1624                            _serde::__private::Ok(ScalarQuantization::BITS16)
1625                        }
1626                    }
1627                }
1628            }
1629            #[doc(hidden)]
1630            const VARIANTS: &'static [&'static str] = &["BITS8", "BITS16"];
1631            _serde::Deserializer::deserialize_enum(
1632                __deserializer,
1633                "ScalarQuantization",
1634                VARIANTS,
1635                __Visitor {
1636                    marker: _serde::__private::PhantomData::<ScalarQuantization>,
1637                    lifetime: _serde::__private::PhantomData,
1638                },
1639            )
1640        }
1641    }
1642};