havok_classes/generated/
hkaRagdollInstance_.rs

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

havok_classes/generated/
hkaRagdollInstance_.rs
