havok_classes/generated/
hkaInterleavedUncompressedAnimation_.rs

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