havok_classes/generated/
hkaWaveletCompressedAnimationCompressionParams_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkaWaveletCompressedAnimationCompressionParams`
5/// - version: `0`
6/// - signature: `0x27c6cafa`
7/// - size: ` 36`(x86)/` 36`(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 hkaWaveletCompressedAnimationCompressionParams {
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: `quantizationBits`(ctype: `hkUint16`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  2`(x86)/`  2`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "quantizationBits"))]
31    #[cfg_attr(feature = "serde", serde(rename = "quantizationBits"))]
32    pub m_quantizationBits: u16,
33    /// # C++ Info
34    /// - name: `blockSize`(ctype: `hkUint16`)
35    /// - offset: `  2`(x86)/`  2`(x86_64)
36    /// - type_size: `  2`(x86)/`  2`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "blockSize"))]
38    #[cfg_attr(feature = "serde", serde(rename = "blockSize"))]
39    pub m_blockSize: u16,
40    /// # C++ Info
41    /// - name: `preserve`(ctype: `hkUint16`)
42    /// - offset: `  4`(x86)/`  4`(x86_64)
43    /// - type_size: `  2`(x86)/`  2`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "preserve"))]
45    #[cfg_attr(feature = "serde", serde(rename = "preserve"))]
46    pub m_preserve: u16,
47    /// # C++ Info
48    /// - name: `truncProp`(ctype: `hkReal`)
49    /// - offset: `  8`(x86)/`  8`(x86_64)
50    /// - type_size: `  4`(x86)/`  4`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "truncProp"))]
52    #[cfg_attr(feature = "serde", serde(rename = "truncProp"))]
53    pub m_truncProp: f32,
54    /// # C++ Info
55    /// - name: `useOldStyleTruncation`(ctype: `hkBool`)
56    /// - offset: ` 12`(x86)/` 12`(x86_64)
57    /// - type_size: `  1`(x86)/`  1`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "useOldStyleTruncation"))]
59    #[cfg_attr(feature = "serde", serde(rename = "useOldStyleTruncation"))]
60    pub m_useOldStyleTruncation: bool,
61    /// # C++ Info
62    /// - name: `absolutePositionTolerance`(ctype: `hkReal`)
63    /// - offset: ` 16`(x86)/` 16`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "absolutePositionTolerance"))]
66    #[cfg_attr(feature = "serde", serde(rename = "absolutePositionTolerance"))]
67    pub m_absolutePositionTolerance: f32,
68    /// # C++ Info
69    /// - name: `relativePositionTolerance`(ctype: `hkReal`)
70    /// - offset: ` 20`(x86)/` 20`(x86_64)
71    /// - type_size: `  4`(x86)/`  4`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "relativePositionTolerance"))]
73    #[cfg_attr(feature = "serde", serde(rename = "relativePositionTolerance"))]
74    pub m_relativePositionTolerance: f32,
75    /// # C++ Info
76    /// - name: `rotationTolerance`(ctype: `hkReal`)
77    /// - offset: ` 24`(x86)/` 24`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "rotationTolerance"))]
80    #[cfg_attr(feature = "serde", serde(rename = "rotationTolerance"))]
81    pub m_rotationTolerance: f32,
82    /// # C++ Info
83    /// - name: `scaleTolerance`(ctype: `hkReal`)
84    /// - offset: ` 28`(x86)/` 28`(x86_64)
85    /// - type_size: `  4`(x86)/`  4`(x86_64)
86    #[cfg_attr(feature = "json_schema", schemars(rename = "scaleTolerance"))]
87    #[cfg_attr(feature = "serde", serde(rename = "scaleTolerance"))]
88    pub m_scaleTolerance: f32,
89    /// # C++ Info
90    /// - name: `absoluteFloatTolerance`(ctype: `hkReal`)
91    /// - offset: ` 32`(x86)/` 32`(x86_64)
92    /// - type_size: `  4`(x86)/`  4`(x86_64)
93    #[cfg_attr(feature = "json_schema", schemars(rename = "absoluteFloatTolerance"))]
94    #[cfg_attr(feature = "serde", serde(rename = "absoluteFloatTolerance"))]
95    pub m_absoluteFloatTolerance: f32,
96}
97const _: () = {
98    use havok_serde as _serde;
99    impl _serde::HavokClass for hkaWaveletCompressedAnimationCompressionParams {
100        #[inline]
101        fn name(&self) -> &'static str {
102            "hkaWaveletCompressedAnimationCompressionParams"
103        }
104        #[inline]
105        fn signature(&self) -> _serde::__private::Signature {
106            _serde::__private::Signature::new(0x27c6cafa)
107        }
108        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
109        fn deps_indexes(&self) -> Vec<usize> {
110            let mut v = Vec::new();
111            v
112        }
113    }
114    impl _serde::Serialize for hkaWaveletCompressedAnimationCompressionParams {
115        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
116        where
117            S: _serde::ser::Serializer,
118        {
119            let class_meta = self
120                .__ptr
121                .map(|name| (name, _serde::__private::Signature::new(0x27c6cafa)));
122            let mut serializer = __serializer
123                .serialize_struct(
124                    "hkaWaveletCompressedAnimationCompressionParams",
125                    class_meta,
126                    (36u64, 36u64),
127                )?;
128            serializer.serialize_field("quantizationBits", &self.m_quantizationBits)?;
129            serializer.serialize_field("blockSize", &self.m_blockSize)?;
130            serializer.serialize_field("preserve", &self.m_preserve)?;
131            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
132            serializer.serialize_field("truncProp", &self.m_truncProp)?;
133            serializer
134                .serialize_field(
135                    "useOldStyleTruncation",
136                    &self.m_useOldStyleTruncation,
137                )?;
138            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
139            serializer
140                .serialize_field(
141                    "absolutePositionTolerance",
142                    &self.m_absolutePositionTolerance,
143                )?;
144            serializer
145                .serialize_field(
146                    "relativePositionTolerance",
147                    &self.m_relativePositionTolerance,
148                )?;
149            serializer.serialize_field("rotationTolerance", &self.m_rotationTolerance)?;
150            serializer.serialize_field("scaleTolerance", &self.m_scaleTolerance)?;
151            serializer
152                .serialize_field(
153                    "absoluteFloatTolerance",
154                    &self.m_absoluteFloatTolerance,
155                )?;
156            serializer.end()
157        }
158    }
159};
160#[doc(hidden)]
161#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
162const _: () = {
163    use havok_serde as _serde;
164    #[automatically_derived]
165    impl<'de> _serde::Deserialize<'de>
166    for hkaWaveletCompressedAnimationCompressionParams {
167        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
168        where
169            __D: _serde::Deserializer<'de>,
170        {
171            #[allow(non_camel_case_types)]
172            enum __Field {
173                m_quantizationBits,
174                m_blockSize,
175                m_preserve,
176                m_truncProp,
177                m_useOldStyleTruncation,
178                m_absolutePositionTolerance,
179                m_relativePositionTolerance,
180                m_rotationTolerance,
181                m_scaleTolerance,
182                m_absoluteFloatTolerance,
183                __ignore,
184            }
185            struct __FieldVisitor;
186            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
187                type Value = __Field;
188                fn expecting(
189                    &self,
190                    __formatter: &mut core::fmt::Formatter,
191                ) -> core::fmt::Result {
192                    core::fmt::Formatter::write_str(__formatter, "field identifier")
193                }
194                /// Intended for use in XML.
195                #[allow(clippy::match_single_binding)]
196                #[allow(clippy::reversed_empty_ranges)]
197                #[allow(clippy::single_match)]
198                fn visit_key<__E>(
199                    self,
200                    __value: &str,
201                ) -> core::result::Result<Self::Value, __E>
202                where
203                    __E: _serde::de::Error,
204                {
205                    match __value {
206                        "quantizationBits" => Ok(__Field::m_quantizationBits),
207                        "blockSize" => Ok(__Field::m_blockSize),
208                        "preserve" => Ok(__Field::m_preserve),
209                        "truncProp" => Ok(__Field::m_truncProp),
210                        "useOldStyleTruncation" => Ok(__Field::m_useOldStyleTruncation),
211                        "absolutePositionTolerance" => {
212                            Ok(__Field::m_absolutePositionTolerance)
213                        }
214                        "relativePositionTolerance" => {
215                            Ok(__Field::m_relativePositionTolerance)
216                        }
217                        "rotationTolerance" => Ok(__Field::m_rotationTolerance),
218                        "scaleTolerance" => Ok(__Field::m_scaleTolerance),
219                        "absoluteFloatTolerance" => Ok(__Field::m_absoluteFloatTolerance),
220                        _ => Ok(__Field::__ignore),
221                    }
222                }
223            }
224            impl<'de> _serde::Deserialize<'de> for __Field {
225                #[inline]
226                fn deserialize<__D>(
227                    __deserializer: __D,
228                ) -> core::result::Result<Self, __D::Error>
229                where
230                    __D: _serde::Deserializer<'de>,
231                {
232                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
233                }
234            }
235            struct __hkaWaveletCompressedAnimationCompressionParamsVisitor<'de> {
236                marker: _serde::__private::PhantomData<
237                    hkaWaveletCompressedAnimationCompressionParams,
238                >,
239                lifetime: _serde::__private::PhantomData<&'de ()>,
240            }
241            #[allow(clippy::match_single_binding)]
242            #[allow(clippy::reversed_empty_ranges)]
243            #[allow(clippy::single_match)]
244            impl<'de> _serde::de::Visitor<'de>
245            for __hkaWaveletCompressedAnimationCompressionParamsVisitor<'de> {
246                type Value = hkaWaveletCompressedAnimationCompressionParams;
247                fn expecting(
248                    &self,
249                    __formatter: &mut core::fmt::Formatter,
250                ) -> core::fmt::Result {
251                    core::fmt::Formatter::write_str(
252                        __formatter,
253                        "struct hkaWaveletCompressedAnimationCompressionParams",
254                    )
255                }
256                fn visit_struct_for_bytes<__A>(
257                    self,
258                    mut __map: __A,
259                ) -> _serde::__private::Result<Self::Value, __A::Error>
260                where
261                    __A: _serde::de::MapAccess<'de>,
262                {
263                    let __ptr = __A::class_ptr(&mut __map);
264                    let mut m_quantizationBits: _serde::__private::Option<u16> = _serde::__private::None;
265                    let mut m_blockSize: _serde::__private::Option<u16> = _serde::__private::None;
266                    let mut m_preserve: _serde::__private::Option<u16> = _serde::__private::None;
267                    let mut m_truncProp: _serde::__private::Option<f32> = _serde::__private::None;
268                    let mut m_useOldStyleTruncation: _serde::__private::Option<bool> = _serde::__private::None;
269                    let mut m_absolutePositionTolerance: _serde::__private::Option<
270                        f32,
271                    > = _serde::__private::None;
272                    let mut m_relativePositionTolerance: _serde::__private::Option<
273                        f32,
274                    > = _serde::__private::None;
275                    let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
276                    let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
277                    let mut m_absoluteFloatTolerance: _serde::__private::Option<f32> = _serde::__private::None;
278                    for i in 0..10usize {
279                        match i {
280                            0usize => {
281                                if _serde::__private::Option::is_some(&m_quantizationBits) {
282                                    return _serde::__private::Err(
283                                        <__A::Error as _serde::de::Error>::duplicate_field(
284                                            "quantizationBits",
285                                        ),
286                                    );
287                                }
288                                m_quantizationBits = _serde::__private::Some(
289                                    match __A::next_value::<u16>(&mut __map) {
290                                        _serde::__private::Ok(__val) => __val,
291                                        _serde::__private::Err(__err) => {
292                                            return _serde::__private::Err(__err);
293                                        }
294                                    },
295                                );
296                            }
297                            1usize => {
298                                if _serde::__private::Option::is_some(&m_blockSize) {
299                                    return _serde::__private::Err(
300                                        <__A::Error as _serde::de::Error>::duplicate_field(
301                                            "blockSize",
302                                        ),
303                                    );
304                                }
305                                m_blockSize = _serde::__private::Some(
306                                    match __A::next_value::<u16>(&mut __map) {
307                                        _serde::__private::Ok(__val) => __val,
308                                        _serde::__private::Err(__err) => {
309                                            return _serde::__private::Err(__err);
310                                        }
311                                    },
312                                );
313                            }
314                            2usize => {
315                                if _serde::__private::Option::is_some(&m_preserve) {
316                                    return _serde::__private::Err(
317                                        <__A::Error as _serde::de::Error>::duplicate_field(
318                                            "preserve",
319                                        ),
320                                    );
321                                }
322                                m_preserve = _serde::__private::Some(
323                                    match __A::next_value::<u16>(&mut __map) {
324                                        _serde::__private::Ok(__val) => __val,
325                                        _serde::__private::Err(__err) => {
326                                            return _serde::__private::Err(__err);
327                                        }
328                                    },
329                                );
330                            }
331                            3usize => {
332                                if _serde::__private::Option::is_some(&m_truncProp) {
333                                    return _serde::__private::Err(
334                                        <__A::Error as _serde::de::Error>::duplicate_field(
335                                            "truncProp",
336                                        ),
337                                    );
338                                }
339                                __A::pad(&mut __map, 2usize, 2usize)?;
340                                m_truncProp = _serde::__private::Some(
341                                    match __A::next_value::<f32>(&mut __map) {
342                                        _serde::__private::Ok(__val) => __val,
343                                        _serde::__private::Err(__err) => {
344                                            return _serde::__private::Err(__err);
345                                        }
346                                    },
347                                );
348                            }
349                            4usize => {
350                                if _serde::__private::Option::is_some(
351                                    &m_useOldStyleTruncation,
352                                ) {
353                                    return _serde::__private::Err(
354                                        <__A::Error as _serde::de::Error>::duplicate_field(
355                                            "useOldStyleTruncation",
356                                        ),
357                                    );
358                                }
359                                m_useOldStyleTruncation = _serde::__private::Some(
360                                    match __A::next_value::<bool>(&mut __map) {
361                                        _serde::__private::Ok(__val) => __val,
362                                        _serde::__private::Err(__err) => {
363                                            return _serde::__private::Err(__err);
364                                        }
365                                    },
366                                );
367                            }
368                            5usize => {
369                                if _serde::__private::Option::is_some(
370                                    &m_absolutePositionTolerance,
371                                ) {
372                                    return _serde::__private::Err(
373                                        <__A::Error as _serde::de::Error>::duplicate_field(
374                                            "absolutePositionTolerance",
375                                        ),
376                                    );
377                                }
378                                __A::pad(&mut __map, 3usize, 3usize)?;
379                                m_absolutePositionTolerance = _serde::__private::Some(
380                                    match __A::next_value::<f32>(&mut __map) {
381                                        _serde::__private::Ok(__val) => __val,
382                                        _serde::__private::Err(__err) => {
383                                            return _serde::__private::Err(__err);
384                                        }
385                                    },
386                                );
387                            }
388                            6usize => {
389                                if _serde::__private::Option::is_some(
390                                    &m_relativePositionTolerance,
391                                ) {
392                                    return _serde::__private::Err(
393                                        <__A::Error as _serde::de::Error>::duplicate_field(
394                                            "relativePositionTolerance",
395                                        ),
396                                    );
397                                }
398                                m_relativePositionTolerance = _serde::__private::Some(
399                                    match __A::next_value::<f32>(&mut __map) {
400                                        _serde::__private::Ok(__val) => __val,
401                                        _serde::__private::Err(__err) => {
402                                            return _serde::__private::Err(__err);
403                                        }
404                                    },
405                                );
406                            }
407                            7usize => {
408                                if _serde::__private::Option::is_some(
409                                    &m_rotationTolerance,
410                                ) {
411                                    return _serde::__private::Err(
412                                        <__A::Error as _serde::de::Error>::duplicate_field(
413                                            "rotationTolerance",
414                                        ),
415                                    );
416                                }
417                                m_rotationTolerance = _serde::__private::Some(
418                                    match __A::next_value::<f32>(&mut __map) {
419                                        _serde::__private::Ok(__val) => __val,
420                                        _serde::__private::Err(__err) => {
421                                            return _serde::__private::Err(__err);
422                                        }
423                                    },
424                                );
425                            }
426                            8usize => {
427                                if _serde::__private::Option::is_some(&m_scaleTolerance) {
428                                    return _serde::__private::Err(
429                                        <__A::Error as _serde::de::Error>::duplicate_field(
430                                            "scaleTolerance",
431                                        ),
432                                    );
433                                }
434                                m_scaleTolerance = _serde::__private::Some(
435                                    match __A::next_value::<f32>(&mut __map) {
436                                        _serde::__private::Ok(__val) => __val,
437                                        _serde::__private::Err(__err) => {
438                                            return _serde::__private::Err(__err);
439                                        }
440                                    },
441                                );
442                            }
443                            9usize => {
444                                if _serde::__private::Option::is_some(
445                                    &m_absoluteFloatTolerance,
446                                ) {
447                                    return _serde::__private::Err(
448                                        <__A::Error as _serde::de::Error>::duplicate_field(
449                                            "absoluteFloatTolerance",
450                                        ),
451                                    );
452                                }
453                                m_absoluteFloatTolerance = _serde::__private::Some(
454                                    match __A::next_value::<f32>(&mut __map) {
455                                        _serde::__private::Ok(__val) => __val,
456                                        _serde::__private::Err(__err) => {
457                                            return _serde::__private::Err(__err);
458                                        }
459                                    },
460                                );
461                            }
462                            _ => {}
463                        }
464                    }
465                    let m_quantizationBits = match m_quantizationBits {
466                        _serde::__private::Some(__field) => __field,
467                        _serde::__private::None => {
468                            return _serde::__private::Err(
469                                <__A::Error as _serde::de::Error>::missing_field(
470                                    "quantizationBits",
471                                ),
472                            );
473                        }
474                    };
475                    let m_blockSize = match m_blockSize {
476                        _serde::__private::Some(__field) => __field,
477                        _serde::__private::None => {
478                            return _serde::__private::Err(
479                                <__A::Error as _serde::de::Error>::missing_field(
480                                    "blockSize",
481                                ),
482                            );
483                        }
484                    };
485                    let m_preserve = match m_preserve {
486                        _serde::__private::Some(__field) => __field,
487                        _serde::__private::None => {
488                            return _serde::__private::Err(
489                                <__A::Error as _serde::de::Error>::missing_field("preserve"),
490                            );
491                        }
492                    };
493                    let m_truncProp = match m_truncProp {
494                        _serde::__private::Some(__field) => __field,
495                        _serde::__private::None => {
496                            return _serde::__private::Err(
497                                <__A::Error as _serde::de::Error>::missing_field(
498                                    "truncProp",
499                                ),
500                            );
501                        }
502                    };
503                    let m_useOldStyleTruncation = match m_useOldStyleTruncation {
504                        _serde::__private::Some(__field) => __field,
505                        _serde::__private::None => {
506                            return _serde::__private::Err(
507                                <__A::Error as _serde::de::Error>::missing_field(
508                                    "useOldStyleTruncation",
509                                ),
510                            );
511                        }
512                    };
513                    let m_absolutePositionTolerance = match m_absolutePositionTolerance {
514                        _serde::__private::Some(__field) => __field,
515                        _serde::__private::None => {
516                            return _serde::__private::Err(
517                                <__A::Error as _serde::de::Error>::missing_field(
518                                    "absolutePositionTolerance",
519                                ),
520                            );
521                        }
522                    };
523                    let m_relativePositionTolerance = match m_relativePositionTolerance {
524                        _serde::__private::Some(__field) => __field,
525                        _serde::__private::None => {
526                            return _serde::__private::Err(
527                                <__A::Error as _serde::de::Error>::missing_field(
528                                    "relativePositionTolerance",
529                                ),
530                            );
531                        }
532                    };
533                    let m_rotationTolerance = match m_rotationTolerance {
534                        _serde::__private::Some(__field) => __field,
535                        _serde::__private::None => {
536                            return _serde::__private::Err(
537                                <__A::Error as _serde::de::Error>::missing_field(
538                                    "rotationTolerance",
539                                ),
540                            );
541                        }
542                    };
543                    let m_scaleTolerance = match m_scaleTolerance {
544                        _serde::__private::Some(__field) => __field,
545                        _serde::__private::None => {
546                            return _serde::__private::Err(
547                                <__A::Error as _serde::de::Error>::missing_field(
548                                    "scaleTolerance",
549                                ),
550                            );
551                        }
552                    };
553                    let m_absoluteFloatTolerance = match m_absoluteFloatTolerance {
554                        _serde::__private::Some(__field) => __field,
555                        _serde::__private::None => {
556                            return _serde::__private::Err(
557                                <__A::Error as _serde::de::Error>::missing_field(
558                                    "absoluteFloatTolerance",
559                                ),
560                            );
561                        }
562                    };
563                    _serde::__private::Ok(hkaWaveletCompressedAnimationCompressionParams {
564                        __ptr,
565                        m_quantizationBits,
566                        m_blockSize,
567                        m_preserve,
568                        m_truncProp,
569                        m_useOldStyleTruncation,
570                        m_absolutePositionTolerance,
571                        m_relativePositionTolerance,
572                        m_rotationTolerance,
573                        m_scaleTolerance,
574                        m_absoluteFloatTolerance,
575                    })
576                }
577                #[allow(clippy::manual_unwrap_or_default)]
578                fn visit_struct<__A>(
579                    self,
580                    mut __map: __A,
581                ) -> _serde::__private::Result<Self::Value, __A::Error>
582                where
583                    __A: _serde::de::MapAccess<'de>,
584                {
585                    let mut m_quantizationBits: _serde::__private::Option<u16> = _serde::__private::None;
586                    let mut m_blockSize: _serde::__private::Option<u16> = _serde::__private::None;
587                    let mut m_preserve: _serde::__private::Option<u16> = _serde::__private::None;
588                    let mut m_truncProp: _serde::__private::Option<f32> = _serde::__private::None;
589                    let mut m_useOldStyleTruncation: _serde::__private::Option<bool> = _serde::__private::None;
590                    let mut m_absolutePositionTolerance: _serde::__private::Option<
591                        f32,
592                    > = _serde::__private::None;
593                    let mut m_relativePositionTolerance: _serde::__private::Option<
594                        f32,
595                    > = _serde::__private::None;
596                    let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
597                    let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
598                    let mut m_absoluteFloatTolerance: _serde::__private::Option<f32> = _serde::__private::None;
599                    while let _serde::__private::Some(__key) = {
600                        __A::next_key::<__Field>(&mut __map)?
601                    } {
602                        match __key {
603                            __Field::m_quantizationBits => {
604                                #[cfg(
605                                    any(feature = "strict", feature = "ignore_duplicates")
606                                )]
607                                if _serde::__private::Option::is_some(&m_quantizationBits) {
608                                    #[cfg(feature = "ignore_duplicates")]
609                                    {
610                                        __A::skip_value(&mut __map)?;
611                                        continue;
612                                    }
613                                    #[cfg(feature = "strict")]
614                                    return _serde::__private::Err(
615                                        <__A::Error as _serde::de::Error>::duplicate_field(
616                                            "quantizationBits",
617                                        ),
618                                    );
619                                }
620                                m_quantizationBits = _serde::__private::Some(
621                                    match __A::next_value::<u16>(&mut __map) {
622                                        _serde::__private::Ok(__val) => __val,
623                                        _serde::__private::Err(__err) => {
624                                            return _serde::__private::Err(__err);
625                                        }
626                                    },
627                                );
628                            }
629                            __Field::m_blockSize => {
630                                #[cfg(
631                                    any(feature = "strict", feature = "ignore_duplicates")
632                                )]
633                                if _serde::__private::Option::is_some(&m_blockSize) {
634                                    #[cfg(feature = "ignore_duplicates")]
635                                    {
636                                        __A::skip_value(&mut __map)?;
637                                        continue;
638                                    }
639                                    #[cfg(feature = "strict")]
640                                    return _serde::__private::Err(
641                                        <__A::Error as _serde::de::Error>::duplicate_field(
642                                            "blockSize",
643                                        ),
644                                    );
645                                }
646                                m_blockSize = _serde::__private::Some(
647                                    match __A::next_value::<u16>(&mut __map) {
648                                        _serde::__private::Ok(__val) => __val,
649                                        _serde::__private::Err(__err) => {
650                                            return _serde::__private::Err(__err);
651                                        }
652                                    },
653                                );
654                            }
655                            __Field::m_preserve => {
656                                #[cfg(
657                                    any(feature = "strict", feature = "ignore_duplicates")
658                                )]
659                                if _serde::__private::Option::is_some(&m_preserve) {
660                                    #[cfg(feature = "ignore_duplicates")]
661                                    {
662                                        __A::skip_value(&mut __map)?;
663                                        continue;
664                                    }
665                                    #[cfg(feature = "strict")]
666                                    return _serde::__private::Err(
667                                        <__A::Error as _serde::de::Error>::duplicate_field(
668                                            "preserve",
669                                        ),
670                                    );
671                                }
672                                m_preserve = _serde::__private::Some(
673                                    match __A::next_value::<u16>(&mut __map) {
674                                        _serde::__private::Ok(__val) => __val,
675                                        _serde::__private::Err(__err) => {
676                                            return _serde::__private::Err(__err);
677                                        }
678                                    },
679                                );
680                            }
681                            __Field::m_truncProp => {
682                                #[cfg(
683                                    any(feature = "strict", feature = "ignore_duplicates")
684                                )]
685                                if _serde::__private::Option::is_some(&m_truncProp) {
686                                    #[cfg(feature = "ignore_duplicates")]
687                                    {
688                                        __A::skip_value(&mut __map)?;
689                                        continue;
690                                    }
691                                    #[cfg(feature = "strict")]
692                                    return _serde::__private::Err(
693                                        <__A::Error as _serde::de::Error>::duplicate_field(
694                                            "truncProp",
695                                        ),
696                                    );
697                                }
698                                m_truncProp = _serde::__private::Some(
699                                    match __A::next_value::<f32>(&mut __map) {
700                                        _serde::__private::Ok(__val) => __val,
701                                        _serde::__private::Err(__err) => {
702                                            return _serde::__private::Err(__err);
703                                        }
704                                    },
705                                );
706                            }
707                            __Field::m_useOldStyleTruncation => {
708                                #[cfg(
709                                    any(feature = "strict", feature = "ignore_duplicates")
710                                )]
711                                if _serde::__private::Option::is_some(
712                                    &m_useOldStyleTruncation,
713                                ) {
714                                    #[cfg(feature = "ignore_duplicates")]
715                                    {
716                                        __A::skip_value(&mut __map)?;
717                                        continue;
718                                    }
719                                    #[cfg(feature = "strict")]
720                                    return _serde::__private::Err(
721                                        <__A::Error as _serde::de::Error>::duplicate_field(
722                                            "useOldStyleTruncation",
723                                        ),
724                                    );
725                                }
726                                m_useOldStyleTruncation = _serde::__private::Some(
727                                    match __A::next_value::<bool>(&mut __map) {
728                                        _serde::__private::Ok(__val) => __val,
729                                        _serde::__private::Err(__err) => {
730                                            return _serde::__private::Err(__err);
731                                        }
732                                    },
733                                );
734                            }
735                            __Field::m_absolutePositionTolerance => {
736                                #[cfg(
737                                    any(feature = "strict", feature = "ignore_duplicates")
738                                )]
739                                if _serde::__private::Option::is_some(
740                                    &m_absolutePositionTolerance,
741                                ) {
742                                    #[cfg(feature = "ignore_duplicates")]
743                                    {
744                                        __A::skip_value(&mut __map)?;
745                                        continue;
746                                    }
747                                    #[cfg(feature = "strict")]
748                                    return _serde::__private::Err(
749                                        <__A::Error as _serde::de::Error>::duplicate_field(
750                                            "absolutePositionTolerance",
751                                        ),
752                                    );
753                                }
754                                m_absolutePositionTolerance = _serde::__private::Some(
755                                    match __A::next_value::<f32>(&mut __map) {
756                                        _serde::__private::Ok(__val) => __val,
757                                        _serde::__private::Err(__err) => {
758                                            return _serde::__private::Err(__err);
759                                        }
760                                    },
761                                );
762                            }
763                            __Field::m_relativePositionTolerance => {
764                                #[cfg(
765                                    any(feature = "strict", feature = "ignore_duplicates")
766                                )]
767                                if _serde::__private::Option::is_some(
768                                    &m_relativePositionTolerance,
769                                ) {
770                                    #[cfg(feature = "ignore_duplicates")]
771                                    {
772                                        __A::skip_value(&mut __map)?;
773                                        continue;
774                                    }
775                                    #[cfg(feature = "strict")]
776                                    return _serde::__private::Err(
777                                        <__A::Error as _serde::de::Error>::duplicate_field(
778                                            "relativePositionTolerance",
779                                        ),
780                                    );
781                                }
782                                m_relativePositionTolerance = _serde::__private::Some(
783                                    match __A::next_value::<f32>(&mut __map) {
784                                        _serde::__private::Ok(__val) => __val,
785                                        _serde::__private::Err(__err) => {
786                                            return _serde::__private::Err(__err);
787                                        }
788                                    },
789                                );
790                            }
791                            __Field::m_rotationTolerance => {
792                                #[cfg(
793                                    any(feature = "strict", feature = "ignore_duplicates")
794                                )]
795                                if _serde::__private::Option::is_some(
796                                    &m_rotationTolerance,
797                                ) {
798                                    #[cfg(feature = "ignore_duplicates")]
799                                    {
800                                        __A::skip_value(&mut __map)?;
801                                        continue;
802                                    }
803                                    #[cfg(feature = "strict")]
804                                    return _serde::__private::Err(
805                                        <__A::Error as _serde::de::Error>::duplicate_field(
806                                            "rotationTolerance",
807                                        ),
808                                    );
809                                }
810                                m_rotationTolerance = _serde::__private::Some(
811                                    match __A::next_value::<f32>(&mut __map) {
812                                        _serde::__private::Ok(__val) => __val,
813                                        _serde::__private::Err(__err) => {
814                                            return _serde::__private::Err(__err);
815                                        }
816                                    },
817                                );
818                            }
819                            __Field::m_scaleTolerance => {
820                                #[cfg(
821                                    any(feature = "strict", feature = "ignore_duplicates")
822                                )]
823                                if _serde::__private::Option::is_some(&m_scaleTolerance) {
824                                    #[cfg(feature = "ignore_duplicates")]
825                                    {
826                                        __A::skip_value(&mut __map)?;
827                                        continue;
828                                    }
829                                    #[cfg(feature = "strict")]
830                                    return _serde::__private::Err(
831                                        <__A::Error as _serde::de::Error>::duplicate_field(
832                                            "scaleTolerance",
833                                        ),
834                                    );
835                                }
836                                m_scaleTolerance = _serde::__private::Some(
837                                    match __A::next_value::<f32>(&mut __map) {
838                                        _serde::__private::Ok(__val) => __val,
839                                        _serde::__private::Err(__err) => {
840                                            return _serde::__private::Err(__err);
841                                        }
842                                    },
843                                );
844                            }
845                            __Field::m_absoluteFloatTolerance => {
846                                #[cfg(
847                                    any(feature = "strict", feature = "ignore_duplicates")
848                                )]
849                                if _serde::__private::Option::is_some(
850                                    &m_absoluteFloatTolerance,
851                                ) {
852                                    #[cfg(feature = "ignore_duplicates")]
853                                    {
854                                        __A::skip_value(&mut __map)?;
855                                        continue;
856                                    }
857                                    #[cfg(feature = "strict")]
858                                    return _serde::__private::Err(
859                                        <__A::Error as _serde::de::Error>::duplicate_field(
860                                            "absoluteFloatTolerance",
861                                        ),
862                                    );
863                                }
864                                m_absoluteFloatTolerance = _serde::__private::Some(
865                                    match __A::next_value::<f32>(&mut __map) {
866                                        _serde::__private::Ok(__val) => __val,
867                                        _serde::__private::Err(__err) => {
868                                            return _serde::__private::Err(__err);
869                                        }
870                                    },
871                                );
872                            }
873                            _ => __A::skip_value(&mut __map)?,
874                        }
875                    }
876                    let m_quantizationBits = match m_quantizationBits {
877                        _serde::__private::Some(__field) => __field,
878                        _serde::__private::None => {
879                            #[cfg(feature = "strict")]
880                            return _serde::__private::Err(
881                                <__A::Error as _serde::de::Error>::missing_field(
882                                    "quantizationBits",
883                                ),
884                            );
885                            #[cfg(not(feature = "strict"))] Default::default()
886                        }
887                    };
888                    let m_blockSize = match m_blockSize {
889                        _serde::__private::Some(__field) => __field,
890                        _serde::__private::None => {
891                            #[cfg(feature = "strict")]
892                            return _serde::__private::Err(
893                                <__A::Error as _serde::de::Error>::missing_field(
894                                    "blockSize",
895                                ),
896                            );
897                            #[cfg(not(feature = "strict"))] Default::default()
898                        }
899                    };
900                    let m_preserve = match m_preserve {
901                        _serde::__private::Some(__field) => __field,
902                        _serde::__private::None => {
903                            #[cfg(feature = "strict")]
904                            return _serde::__private::Err(
905                                <__A::Error as _serde::de::Error>::missing_field("preserve"),
906                            );
907                            #[cfg(not(feature = "strict"))] Default::default()
908                        }
909                    };
910                    let m_truncProp = match m_truncProp {
911                        _serde::__private::Some(__field) => __field,
912                        _serde::__private::None => {
913                            #[cfg(feature = "strict")]
914                            return _serde::__private::Err(
915                                <__A::Error as _serde::de::Error>::missing_field(
916                                    "truncProp",
917                                ),
918                            );
919                            #[cfg(not(feature = "strict"))] Default::default()
920                        }
921                    };
922                    let m_useOldStyleTruncation = match m_useOldStyleTruncation {
923                        _serde::__private::Some(__field) => __field,
924                        _serde::__private::None => {
925                            #[cfg(feature = "strict")]
926                            return _serde::__private::Err(
927                                <__A::Error as _serde::de::Error>::missing_field(
928                                    "useOldStyleTruncation",
929                                ),
930                            );
931                            #[cfg(not(feature = "strict"))] Default::default()
932                        }
933                    };
934                    let m_absolutePositionTolerance = match m_absolutePositionTolerance {
935                        _serde::__private::Some(__field) => __field,
936                        _serde::__private::None => {
937                            #[cfg(feature = "strict")]
938                            return _serde::__private::Err(
939                                <__A::Error as _serde::de::Error>::missing_field(
940                                    "absolutePositionTolerance",
941                                ),
942                            );
943                            #[cfg(not(feature = "strict"))] Default::default()
944                        }
945                    };
946                    let m_relativePositionTolerance = match m_relativePositionTolerance {
947                        _serde::__private::Some(__field) => __field,
948                        _serde::__private::None => {
949                            #[cfg(feature = "strict")]
950                            return _serde::__private::Err(
951                                <__A::Error as _serde::de::Error>::missing_field(
952                                    "relativePositionTolerance",
953                                ),
954                            );
955                            #[cfg(not(feature = "strict"))] Default::default()
956                        }
957                    };
958                    let m_rotationTolerance = match m_rotationTolerance {
959                        _serde::__private::Some(__field) => __field,
960                        _serde::__private::None => {
961                            #[cfg(feature = "strict")]
962                            return _serde::__private::Err(
963                                <__A::Error as _serde::de::Error>::missing_field(
964                                    "rotationTolerance",
965                                ),
966                            );
967                            #[cfg(not(feature = "strict"))] Default::default()
968                        }
969                    };
970                    let m_scaleTolerance = match m_scaleTolerance {
971                        _serde::__private::Some(__field) => __field,
972                        _serde::__private::None => {
973                            #[cfg(feature = "strict")]
974                            return _serde::__private::Err(
975                                <__A::Error as _serde::de::Error>::missing_field(
976                                    "scaleTolerance",
977                                ),
978                            );
979                            #[cfg(not(feature = "strict"))] Default::default()
980                        }
981                    };
982                    let m_absoluteFloatTolerance = match m_absoluteFloatTolerance {
983                        _serde::__private::Some(__field) => __field,
984                        _serde::__private::None => {
985                            #[cfg(feature = "strict")]
986                            return _serde::__private::Err(
987                                <__A::Error as _serde::de::Error>::missing_field(
988                                    "absoluteFloatTolerance",
989                                ),
990                            );
991                            #[cfg(not(feature = "strict"))] Default::default()
992                        }
993                    };
994                    let __ptr = __A::class_ptr(&mut __map);
995                    _serde::__private::Ok(hkaWaveletCompressedAnimationCompressionParams {
996                        __ptr,
997                        m_quantizationBits,
998                        m_blockSize,
999                        m_preserve,
1000                        m_truncProp,
1001                        m_useOldStyleTruncation,
1002                        m_absolutePositionTolerance,
1003                        m_relativePositionTolerance,
1004                        m_rotationTolerance,
1005                        m_scaleTolerance,
1006                        m_absoluteFloatTolerance,
1007                    })
1008                }
1009            }
1010            const FIELDS: &[&str] = &[
1011                "quantizationBits",
1012                "blockSize",
1013                "preserve",
1014                "truncProp",
1015                "useOldStyleTruncation",
1016                "absolutePositionTolerance",
1017                "relativePositionTolerance",
1018                "rotationTolerance",
1019                "scaleTolerance",
1020                "absoluteFloatTolerance",
1021            ];
1022            _serde::Deserializer::deserialize_struct(
1023                deserializer,
1024                "hkaWaveletCompressedAnimationCompressionParams",
1025                FIELDS,
1026                __hkaWaveletCompressedAnimationCompressionParamsVisitor {
1027                    marker: _serde::__private::PhantomData::<
1028                        hkaWaveletCompressedAnimationCompressionParams,
1029                    >,
1030                    lifetime: _serde::__private::PhantomData,
1031                },
1032            )
1033        }
1034    }
1035};