havok_classes/generated/
hkaAnimationContainer_.rs

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

havok_classes/generated/
hkaAnimationContainer_.rs
