havok_classes/generated/
hkaAnimation_.rs

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