havok_classes/generated/
hkpRigidBody_.rs

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