havok_classes/generated/
hkaWaveletCompressedAnimation_.rs

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