havok_classes/generated/
hkaQuantizedAnimation_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkaQuantizedAnimation`
5/// - version: `0`
6/// - signature: `0x3920f053`
7/// - size: ` 60`(x86)/` 88`(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 hkaQuantizedAnimation<'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: `data`(ctype: `hkArray<hkUint8>`)
33    /// - offset: ` 40`(x86)/` 56`(x86_64)
34    /// - type_size: ` 12`(x86)/` 16`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
36    #[cfg_attr(feature = "serde", serde(rename = "data"))]
37    pub m_data: Vec<u8>,
38    /// # C++ Info
39    /// - name: `endian`(ctype: `hkUint32`)
40    /// - offset: ` 52`(x86)/` 72`(x86_64)
41    /// - type_size: `  4`(x86)/`  4`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "endian"))]
43    #[cfg_attr(feature = "serde", serde(rename = "endian"))]
44    pub m_endian: u32,
45    /// # C++ Info
46    /// - name: `skeleton`(ctype: `void*`)
47    /// - offset: ` 56`(x86)/` 80`(x86_64)
48    /// - type_size: `  4`(x86)/`  8`(x86_64)
49    /// - flags: `SERIALIZE_IGNORED`
50    #[cfg_attr(feature = "json_schema", schemars(rename = "skeleton"))]
51    #[cfg_attr(feature = "serde", serde(rename = "skeleton"))]
52    pub m_skeleton: Pointer,
53}
54const _: () = {
55    use havok_serde as _serde;
56    impl<'a> _serde::HavokClass for hkaQuantizedAnimation<'a> {
57        #[inline]
58        fn name(&self) -> &'static str {
59            "hkaQuantizedAnimation"
60        }
61        #[inline]
62        fn signature(&self) -> _serde::__private::Signature {
63            _serde::__private::Signature::new(0x3920f053)
64        }
65        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
66        fn deps_indexes(&self) -> Vec<usize> {
67            let mut v = Vec::new();
68            v.push(self.parent.m_extractedMotion.get());
69            v.extend(
70                self
71                    .parent
72                    .m_annotationTracks
73                    .iter()
74                    .flat_map(|class| class.deps_indexes())
75                    .collect::<Vec<usize>>(),
76            );
77            v.push(self.m_skeleton.get());
78            v
79        }
80    }
81    impl<'a> _serde::Serialize for hkaQuantizedAnimation<'a> {
82        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
83        where
84            S: _serde::ser::Serializer,
85        {
86            let class_meta = self
87                .__ptr
88                .map(|name| (name, _serde::__private::Signature::new(0x3920f053)));
89            let mut serializer = __serializer
90                .serialize_struct("hkaQuantizedAnimation", class_meta, (60u64, 88u64))?;
91            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
92            serializer
93                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
94            serializer
95                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
96            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
97            serializer.serialize_field("type", &self.parent.m_type)?;
98            serializer.serialize_field("duration", &self.parent.m_duration)?;
99            serializer
100                .serialize_field(
101                    "numberOfTransformTracks",
102                    &self.parent.m_numberOfTransformTracks,
103                )?;
104            serializer
105                .serialize_field(
106                    "numberOfFloatTracks",
107                    &self.parent.m_numberOfFloatTracks,
108                )?;
109            serializer
110                .serialize_field("extractedMotion", &self.parent.m_extractedMotion)?;
111            serializer
112                .serialize_array_field(
113                    "annotationTracks",
114                    &self.parent.m_annotationTracks,
115                    TypeSize::Struct {
116                        size_x86: 16u64,
117                        size_x86_64: 24u64,
118                    },
119                )?;
120            serializer.serialize_array_field("data", &self.m_data, TypeSize::NonPtr)?;
121            serializer.serialize_field("endian", &self.m_endian)?;
122            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
123            serializer.skip_field("skeleton", &self.m_skeleton)?;
124            serializer.end()
125        }
126    }
127};
128#[doc(hidden)]
129#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
130const _: () = {
131    use havok_serde as _serde;
132    #[automatically_derived]
133    impl<'de> _serde::Deserialize<'de> for hkaQuantizedAnimation<'de> {
134        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
135        where
136            __D: _serde::Deserializer<'de>,
137        {
138            #[allow(non_camel_case_types)]
139            enum __Field {
140                m_type,
141                m_duration,
142                m_numberOfTransformTracks,
143                m_numberOfFloatTracks,
144                m_extractedMotion,
145                m_annotationTracks,
146                m_data,
147                m_endian,
148                __ignore,
149            }
150            struct __FieldVisitor;
151            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
152                type Value = __Field;
153                fn expecting(
154                    &self,
155                    __formatter: &mut core::fmt::Formatter,
156                ) -> core::fmt::Result {
157                    core::fmt::Formatter::write_str(__formatter, "field identifier")
158                }
159                /// Intended for use in XML.
160                #[allow(clippy::match_single_binding)]
161                #[allow(clippy::reversed_empty_ranges)]
162                #[allow(clippy::single_match)]
163                fn visit_key<__E>(
164                    self,
165                    __value: &str,
166                ) -> core::result::Result<Self::Value, __E>
167                where
168                    __E: _serde::de::Error,
169                {
170                    match __value {
171                        "type" => Ok(__Field::m_type),
172                        "duration" => Ok(__Field::m_duration),
173                        "numberOfTransformTracks" => {
174                            Ok(__Field::m_numberOfTransformTracks)
175                        }
176                        "numberOfFloatTracks" => Ok(__Field::m_numberOfFloatTracks),
177                        "extractedMotion" => Ok(__Field::m_extractedMotion),
178                        "annotationTracks" => Ok(__Field::m_annotationTracks),
179                        "data" => Ok(__Field::m_data),
180                        "endian" => Ok(__Field::m_endian),
181                        _ => Ok(__Field::__ignore),
182                    }
183                }
184            }
185            impl<'de> _serde::Deserialize<'de> for __Field {
186                #[inline]
187                fn deserialize<__D>(
188                    __deserializer: __D,
189                ) -> core::result::Result<Self, __D::Error>
190                where
191                    __D: _serde::Deserializer<'de>,
192                {
193                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
194                }
195            }
196            struct __hkaQuantizedAnimationVisitor<'de> {
197                marker: _serde::__private::PhantomData<hkaQuantizedAnimation<'de>>,
198                lifetime: _serde::__private::PhantomData<&'de ()>,
199            }
200            #[allow(clippy::match_single_binding)]
201            #[allow(clippy::reversed_empty_ranges)]
202            #[allow(clippy::single_match)]
203            impl<'de> _serde::de::Visitor<'de> for __hkaQuantizedAnimationVisitor<'de> {
204                type Value = hkaQuantizedAnimation<'de>;
205                fn expecting(
206                    &self,
207                    __formatter: &mut core::fmt::Formatter,
208                ) -> core::fmt::Result {
209                    core::fmt::Formatter::write_str(
210                        __formatter,
211                        "struct hkaQuantizedAnimation",
212                    )
213                }
214                fn visit_struct_for_bytes<__A>(
215                    self,
216                    mut __map: __A,
217                ) -> _serde::__private::Result<Self::Value, __A::Error>
218                where
219                    __A: _serde::de::MapAccess<'de>,
220                {
221                    let __ptr = __A::class_ptr(&mut __map);
222                    let parent = __A::parent_value(&mut __map)?;
223                    let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
224                    let mut m_endian: _serde::__private::Option<u32> = _serde::__private::None;
225                    let mut m_skeleton: _serde::__private::Option<Pointer> = _serde::__private::None;
226                    for i in 0..3usize {
227                        match i {
228                            0usize => {
229                                if _serde::__private::Option::is_some(&m_data) {
230                                    return _serde::__private::Err(
231                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
232                                    );
233                                }
234                                m_data = _serde::__private::Some(
235                                    match __A::next_value::<Vec<u8>>(&mut __map) {
236                                        _serde::__private::Ok(__val) => __val,
237                                        _serde::__private::Err(__err) => {
238                                            return _serde::__private::Err(__err);
239                                        }
240                                    },
241                                );
242                            }
243                            1usize => {
244                                if _serde::__private::Option::is_some(&m_endian) {
245                                    return _serde::__private::Err(
246                                        <__A::Error as _serde::de::Error>::duplicate_field("endian"),
247                                    );
248                                }
249                                m_endian = _serde::__private::Some(
250                                    match __A::next_value::<u32>(&mut __map) {
251                                        _serde::__private::Ok(__val) => __val,
252                                        _serde::__private::Err(__err) => {
253                                            return _serde::__private::Err(__err);
254                                        }
255                                    },
256                                );
257                            }
258                            2usize => {
259                                if _serde::__private::Option::is_some(&m_skeleton) {
260                                    return _serde::__private::Err(
261                                        <__A::Error as _serde::de::Error>::duplicate_field(
262                                            "skeleton",
263                                        ),
264                                    );
265                                }
266                                __A::pad(&mut __map, 0usize, 4usize)?;
267                                m_skeleton = _serde::__private::Some(
268                                    match __A::next_value::<Pointer>(&mut __map) {
269                                        _serde::__private::Ok(__val) => __val,
270                                        _serde::__private::Err(__err) => {
271                                            return _serde::__private::Err(__err);
272                                        }
273                                    },
274                                );
275                            }
276                            _ => {}
277                        }
278                    }
279                    let m_data = match m_data {
280                        _serde::__private::Some(__field) => __field,
281                        _serde::__private::None => {
282                            return _serde::__private::Err(
283                                <__A::Error as _serde::de::Error>::missing_field("data"),
284                            );
285                        }
286                    };
287                    let m_endian = match m_endian {
288                        _serde::__private::Some(__field) => __field,
289                        _serde::__private::None => {
290                            return _serde::__private::Err(
291                                <__A::Error as _serde::de::Error>::missing_field("endian"),
292                            );
293                        }
294                    };
295                    let m_skeleton = match m_skeleton {
296                        _serde::__private::Some(__field) => __field,
297                        _serde::__private::None => {
298                            return _serde::__private::Err(
299                                <__A::Error as _serde::de::Error>::missing_field("skeleton"),
300                            );
301                        }
302                    };
303                    _serde::__private::Ok(hkaQuantizedAnimation {
304                        __ptr,
305                        parent,
306                        m_data,
307                        m_endian,
308                        m_skeleton,
309                    })
310                }
311                #[allow(clippy::manual_unwrap_or_default)]
312                fn visit_struct<__A>(
313                    self,
314                    mut __map: __A,
315                ) -> _serde::__private::Result<Self::Value, __A::Error>
316                where
317                    __A: _serde::de::MapAccess<'de>,
318                {
319                    let mut m_type: _serde::__private::Option<AnimationType> = _serde::__private::None;
320                    let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
321                    let mut m_numberOfTransformTracks: _serde::__private::Option<i32> = _serde::__private::None;
322                    let mut m_numberOfFloatTracks: _serde::__private::Option<i32> = _serde::__private::None;
323                    let mut m_extractedMotion: _serde::__private::Option<Pointer> = _serde::__private::None;
324                    let mut m_annotationTracks: _serde::__private::Option<
325                        Vec<hkaAnnotationTrack<'de>>,
326                    > = _serde::__private::None;
327                    let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
328                    let mut m_endian: _serde::__private::Option<u32> = _serde::__private::None;
329                    while let _serde::__private::Some(__key) = {
330                        __A::next_key::<__Field>(&mut __map)?
331                    } {
332                        match __key {
333                            __Field::m_type => {
334                                #[cfg(
335                                    any(feature = "strict", feature = "ignore_duplicates")
336                                )]
337                                if _serde::__private::Option::is_some(&m_type) {
338                                    #[cfg(feature = "ignore_duplicates")]
339                                    {
340                                        __A::skip_value(&mut __map)?;
341                                        continue;
342                                    }
343                                    #[cfg(feature = "strict")]
344                                    return _serde::__private::Err(
345                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
346                                    );
347                                }
348                                m_type = _serde::__private::Some(
349                                    match __A::next_value::<AnimationType>(&mut __map) {
350                                        _serde::__private::Ok(__val) => __val,
351                                        _serde::__private::Err(__err) => {
352                                            return _serde::__private::Err(__err);
353                                        }
354                                    },
355                                );
356                            }
357                            __Field::m_duration => {
358                                #[cfg(
359                                    any(feature = "strict", feature = "ignore_duplicates")
360                                )]
361                                if _serde::__private::Option::is_some(&m_duration) {
362                                    #[cfg(feature = "ignore_duplicates")]
363                                    {
364                                        __A::skip_value(&mut __map)?;
365                                        continue;
366                                    }
367                                    #[cfg(feature = "strict")]
368                                    return _serde::__private::Err(
369                                        <__A::Error as _serde::de::Error>::duplicate_field(
370                                            "duration",
371                                        ),
372                                    );
373                                }
374                                m_duration = _serde::__private::Some(
375                                    match __A::next_value::<f32>(&mut __map) {
376                                        _serde::__private::Ok(__val) => __val,
377                                        _serde::__private::Err(__err) => {
378                                            return _serde::__private::Err(__err);
379                                        }
380                                    },
381                                );
382                            }
383                            __Field::m_numberOfTransformTracks => {
384                                #[cfg(
385                                    any(feature = "strict", feature = "ignore_duplicates")
386                                )]
387                                if _serde::__private::Option::is_some(
388                                    &m_numberOfTransformTracks,
389                                ) {
390                                    #[cfg(feature = "ignore_duplicates")]
391                                    {
392                                        __A::skip_value(&mut __map)?;
393                                        continue;
394                                    }
395                                    #[cfg(feature = "strict")]
396                                    return _serde::__private::Err(
397                                        <__A::Error as _serde::de::Error>::duplicate_field(
398                                            "numberOfTransformTracks",
399                                        ),
400                                    );
401                                }
402                                m_numberOfTransformTracks = _serde::__private::Some(
403                                    match __A::next_value::<i32>(&mut __map) {
404                                        _serde::__private::Ok(__val) => __val,
405                                        _serde::__private::Err(__err) => {
406                                            return _serde::__private::Err(__err);
407                                        }
408                                    },
409                                );
410                            }
411                            __Field::m_numberOfFloatTracks => {
412                                #[cfg(
413                                    any(feature = "strict", feature = "ignore_duplicates")
414                                )]
415                                if _serde::__private::Option::is_some(
416                                    &m_numberOfFloatTracks,
417                                ) {
418                                    #[cfg(feature = "ignore_duplicates")]
419                                    {
420                                        __A::skip_value(&mut __map)?;
421                                        continue;
422                                    }
423                                    #[cfg(feature = "strict")]
424                                    return _serde::__private::Err(
425                                        <__A::Error as _serde::de::Error>::duplicate_field(
426                                            "numberOfFloatTracks",
427                                        ),
428                                    );
429                                }
430                                m_numberOfFloatTracks = _serde::__private::Some(
431                                    match __A::next_value::<i32>(&mut __map) {
432                                        _serde::__private::Ok(__val) => __val,
433                                        _serde::__private::Err(__err) => {
434                                            return _serde::__private::Err(__err);
435                                        }
436                                    },
437                                );
438                            }
439                            __Field::m_extractedMotion => {
440                                #[cfg(
441                                    any(feature = "strict", feature = "ignore_duplicates")
442                                )]
443                                if _serde::__private::Option::is_some(&m_extractedMotion) {
444                                    #[cfg(feature = "ignore_duplicates")]
445                                    {
446                                        __A::skip_value(&mut __map)?;
447                                        continue;
448                                    }
449                                    #[cfg(feature = "strict")]
450                                    return _serde::__private::Err(
451                                        <__A::Error as _serde::de::Error>::duplicate_field(
452                                            "extractedMotion",
453                                        ),
454                                    );
455                                }
456                                m_extractedMotion = _serde::__private::Some(
457                                    match __A::next_value::<Pointer>(&mut __map) {
458                                        _serde::__private::Ok(__val) => __val,
459                                        _serde::__private::Err(__err) => {
460                                            return _serde::__private::Err(__err);
461                                        }
462                                    },
463                                );
464                            }
465                            __Field::m_annotationTracks => {
466                                #[cfg(
467                                    any(feature = "strict", feature = "ignore_duplicates")
468                                )]
469                                if _serde::__private::Option::is_some(&m_annotationTracks) {
470                                    #[cfg(feature = "ignore_duplicates")]
471                                    {
472                                        __A::skip_value(&mut __map)?;
473                                        continue;
474                                    }
475                                    #[cfg(feature = "strict")]
476                                    return _serde::__private::Err(
477                                        <__A::Error as _serde::de::Error>::duplicate_field(
478                                            "annotationTracks",
479                                        ),
480                                    );
481                                }
482                                m_annotationTracks = _serde::__private::Some(
483                                    match __A::next_value::<
484                                        Vec<hkaAnnotationTrack<'de>>,
485                                    >(&mut __map) {
486                                        _serde::__private::Ok(__val) => __val,
487                                        _serde::__private::Err(__err) => {
488                                            return _serde::__private::Err(__err);
489                                        }
490                                    },
491                                );
492                            }
493                            __Field::m_data => {
494                                #[cfg(
495                                    any(feature = "strict", feature = "ignore_duplicates")
496                                )]
497                                if _serde::__private::Option::is_some(&m_data) {
498                                    #[cfg(feature = "ignore_duplicates")]
499                                    {
500                                        __A::skip_value(&mut __map)?;
501                                        continue;
502                                    }
503                                    #[cfg(feature = "strict")]
504                                    return _serde::__private::Err(
505                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
506                                    );
507                                }
508                                m_data = _serde::__private::Some(
509                                    match __A::next_value::<Vec<u8>>(&mut __map) {
510                                        _serde::__private::Ok(__val) => __val,
511                                        _serde::__private::Err(__err) => {
512                                            return _serde::__private::Err(__err);
513                                        }
514                                    },
515                                );
516                            }
517                            __Field::m_endian => {
518                                #[cfg(
519                                    any(feature = "strict", feature = "ignore_duplicates")
520                                )]
521                                if _serde::__private::Option::is_some(&m_endian) {
522                                    #[cfg(feature = "ignore_duplicates")]
523                                    {
524                                        __A::skip_value(&mut __map)?;
525                                        continue;
526                                    }
527                                    #[cfg(feature = "strict")]
528                                    return _serde::__private::Err(
529                                        <__A::Error as _serde::de::Error>::duplicate_field("endian"),
530                                    );
531                                }
532                                m_endian = _serde::__private::Some(
533                                    match __A::next_value::<u32>(&mut __map) {
534                                        _serde::__private::Ok(__val) => __val,
535                                        _serde::__private::Err(__err) => {
536                                            return _serde::__private::Err(__err);
537                                        }
538                                    },
539                                );
540                            }
541                            _ => __A::skip_value(&mut __map)?,
542                        }
543                    }
544                    let m_type = match m_type {
545                        _serde::__private::Some(__field) => __field,
546                        _serde::__private::None => {
547                            #[cfg(feature = "strict")]
548                            return _serde::__private::Err(
549                                <__A::Error as _serde::de::Error>::missing_field("type"),
550                            );
551                            #[cfg(not(feature = "strict"))] Default::default()
552                        }
553                    };
554                    let m_duration = match m_duration {
555                        _serde::__private::Some(__field) => __field,
556                        _serde::__private::None => {
557                            #[cfg(feature = "strict")]
558                            return _serde::__private::Err(
559                                <__A::Error as _serde::de::Error>::missing_field("duration"),
560                            );
561                            #[cfg(not(feature = "strict"))] Default::default()
562                        }
563                    };
564                    let m_numberOfTransformTracks = match m_numberOfTransformTracks {
565                        _serde::__private::Some(__field) => __field,
566                        _serde::__private::None => {
567                            #[cfg(feature = "strict")]
568                            return _serde::__private::Err(
569                                <__A::Error as _serde::de::Error>::missing_field(
570                                    "numberOfTransformTracks",
571                                ),
572                            );
573                            #[cfg(not(feature = "strict"))] Default::default()
574                        }
575                    };
576                    let m_numberOfFloatTracks = match m_numberOfFloatTracks {
577                        _serde::__private::Some(__field) => __field,
578                        _serde::__private::None => {
579                            #[cfg(feature = "strict")]
580                            return _serde::__private::Err(
581                                <__A::Error as _serde::de::Error>::missing_field(
582                                    "numberOfFloatTracks",
583                                ),
584                            );
585                            #[cfg(not(feature = "strict"))] Default::default()
586                        }
587                    };
588                    let m_extractedMotion = match m_extractedMotion {
589                        _serde::__private::Some(__field) => __field,
590                        _serde::__private::None => {
591                            #[cfg(feature = "strict")]
592                            return _serde::__private::Err(
593                                <__A::Error as _serde::de::Error>::missing_field(
594                                    "extractedMotion",
595                                ),
596                            );
597                            #[cfg(not(feature = "strict"))] Default::default()
598                        }
599                    };
600                    let m_annotationTracks = match m_annotationTracks {
601                        _serde::__private::Some(__field) => __field,
602                        _serde::__private::None => {
603                            #[cfg(feature = "strict")]
604                            return _serde::__private::Err(
605                                <__A::Error as _serde::de::Error>::missing_field(
606                                    "annotationTracks",
607                                ),
608                            );
609                            #[cfg(not(feature = "strict"))] Default::default()
610                        }
611                    };
612                    let m_data = match m_data {
613                        _serde::__private::Some(__field) => __field,
614                        _serde::__private::None => {
615                            #[cfg(feature = "strict")]
616                            return _serde::__private::Err(
617                                <__A::Error as _serde::de::Error>::missing_field("data"),
618                            );
619                            #[cfg(not(feature = "strict"))] Default::default()
620                        }
621                    };
622                    let m_endian = match m_endian {
623                        _serde::__private::Some(__field) => __field,
624                        _serde::__private::None => {
625                            #[cfg(feature = "strict")]
626                            return _serde::__private::Err(
627                                <__A::Error as _serde::de::Error>::missing_field("endian"),
628                            );
629                            #[cfg(not(feature = "strict"))] Default::default()
630                        }
631                    };
632                    let __ptr = None;
633                    let parent = hkBaseObject { __ptr };
634                    let parent = hkReferencedObject {
635                        __ptr,
636                        parent,
637                        ..Default::default()
638                    };
639                    let parent = hkaAnimation {
640                        __ptr,
641                        parent,
642                        m_type,
643                        m_duration,
644                        m_numberOfTransformTracks,
645                        m_numberOfFloatTracks,
646                        m_extractedMotion,
647                        m_annotationTracks,
648                    };
649                    let __ptr = __A::class_ptr(&mut __map);
650                    _serde::__private::Ok(hkaQuantizedAnimation {
651                        __ptr,
652                        parent,
653                        m_data,
654                        m_endian,
655                        ..Default::default()
656                    })
657                }
658            }
659            const FIELDS: &[&str] = &["data", "endian", "skeleton"];
660            _serde::Deserializer::deserialize_struct(
661                deserializer,
662                "hkaQuantizedAnimation",
663                FIELDS,
664                __hkaQuantizedAnimationVisitor {
665                    marker: _serde::__private::PhantomData::<hkaQuantizedAnimation>,
666                    lifetime: _serde::__private::PhantomData,
667                },
668            )
669        }
670    }
671};