havok_classes/generated/
hkpCharacterRigidBodyCinfo_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpCharacterRigidBodyCinfo`
5/// - version: `0`
6/// - signature: `0x892f441`
7/// - size: `112`(x86)/`128`(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 hkpCharacterRigidBodyCinfo {
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: hkpCharacterControllerCinfo,
30    /// # C++ Info
31    /// - name: `collisionFilterInfo`(ctype: `hkUint32`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  4`(x86)/`  4`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "collisionFilterInfo"))]
35    #[cfg_attr(feature = "serde", serde(rename = "collisionFilterInfo"))]
36    pub m_collisionFilterInfo: u32,
37    /// # C++ Info
38    /// - name: `shape`(ctype: `struct hkpShape*`)
39    /// - offset: ` 12`(x86)/` 24`(x86_64)
40    /// - type_size: `  4`(x86)/`  8`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "shape"))]
42    #[cfg_attr(feature = "serde", serde(rename = "shape"))]
43    pub m_shape: Pointer,
44    /// # C++ Info
45    /// - name: `position`(ctype: `hkVector4`)
46    /// - offset: ` 16`(x86)/` 32`(x86_64)
47    /// - type_size: ` 16`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "position"))]
49    #[cfg_attr(feature = "serde", serde(rename = "position"))]
50    pub m_position: Vector4,
51    /// # C++ Info
52    /// - name: `rotation`(ctype: `hkQuaternion`)
53    /// - offset: ` 32`(x86)/` 48`(x86_64)
54    /// - type_size: ` 16`(x86)/` 16`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "rotation"))]
56    #[cfg_attr(feature = "serde", serde(rename = "rotation"))]
57    pub m_rotation: Quaternion,
58    /// # C++ Info
59    /// - name: `mass`(ctype: `hkReal`)
60    /// - offset: ` 48`(x86)/` 64`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "mass"))]
63    #[cfg_attr(feature = "serde", serde(rename = "mass"))]
64    pub m_mass: f32,
65    /// # C++ Info
66    /// - name: `friction`(ctype: `hkReal`)
67    /// - offset: ` 52`(x86)/` 68`(x86_64)
68    /// - type_size: `  4`(x86)/`  4`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "friction"))]
70    #[cfg_attr(feature = "serde", serde(rename = "friction"))]
71    pub m_friction: f32,
72    /// # C++ Info
73    /// - name: `maxLinearVelocity`(ctype: `hkReal`)
74    /// - offset: ` 56`(x86)/` 72`(x86_64)
75    /// - type_size: `  4`(x86)/`  4`(x86_64)
76    #[cfg_attr(feature = "json_schema", schemars(rename = "maxLinearVelocity"))]
77    #[cfg_attr(feature = "serde", serde(rename = "maxLinearVelocity"))]
78    pub m_maxLinearVelocity: f32,
79    /// # C++ Info
80    /// - name: `allowedPenetrationDepth`(ctype: `hkReal`)
81    /// - offset: ` 60`(x86)/` 76`(x86_64)
82    /// - type_size: `  4`(x86)/`  4`(x86_64)
83    #[cfg_attr(feature = "json_schema", schemars(rename = "allowedPenetrationDepth"))]
84    #[cfg_attr(feature = "serde", serde(rename = "allowedPenetrationDepth"))]
85    pub m_allowedPenetrationDepth: f32,
86    /// # C++ Info
87    /// - name: `up`(ctype: `hkVector4`)
88    /// - offset: ` 64`(x86)/` 80`(x86_64)
89    /// - type_size: ` 16`(x86)/` 16`(x86_64)
90    #[cfg_attr(feature = "json_schema", schemars(rename = "up"))]
91    #[cfg_attr(feature = "serde", serde(rename = "up"))]
92    pub m_up: Vector4,
93    /// # C++ Info
94    /// - name: `maxSlope`(ctype: `hkReal`)
95    /// - offset: ` 80`(x86)/` 96`(x86_64)
96    /// - type_size: `  4`(x86)/`  4`(x86_64)
97    #[cfg_attr(feature = "json_schema", schemars(rename = "maxSlope"))]
98    #[cfg_attr(feature = "serde", serde(rename = "maxSlope"))]
99    pub m_maxSlope: f32,
100    /// # C++ Info
101    /// - name: `maxForce`(ctype: `hkReal`)
102    /// - offset: ` 84`(x86)/`100`(x86_64)
103    /// - type_size: `  4`(x86)/`  4`(x86_64)
104    #[cfg_attr(feature = "json_schema", schemars(rename = "maxForce"))]
105    #[cfg_attr(feature = "serde", serde(rename = "maxForce"))]
106    pub m_maxForce: f32,
107    /// # C++ Info
108    /// - name: `unweldingHeightOffsetFactor`(ctype: `hkReal`)
109    /// - offset: ` 88`(x86)/`104`(x86_64)
110    /// - type_size: `  4`(x86)/`  4`(x86_64)
111    #[cfg_attr(
112        feature = "json_schema",
113        schemars(rename = "unweldingHeightOffsetFactor")
114    )]
115    #[cfg_attr(feature = "serde", serde(rename = "unweldingHeightOffsetFactor"))]
116    pub m_unweldingHeightOffsetFactor: f32,
117    /// # C++ Info
118    /// - name: `maxSpeedForSimplexSolver`(ctype: `hkReal`)
119    /// - offset: ` 92`(x86)/`108`(x86_64)
120    /// - type_size: `  4`(x86)/`  4`(x86_64)
121    #[cfg_attr(feature = "json_schema", schemars(rename = "maxSpeedForSimplexSolver"))]
122    #[cfg_attr(feature = "serde", serde(rename = "maxSpeedForSimplexSolver"))]
123    pub m_maxSpeedForSimplexSolver: f32,
124    /// # C++ Info
125    /// - name: `supportDistance`(ctype: `hkReal`)
126    /// - offset: ` 96`(x86)/`112`(x86_64)
127    /// - type_size: `  4`(x86)/`  4`(x86_64)
128    #[cfg_attr(feature = "json_schema", schemars(rename = "supportDistance"))]
129    #[cfg_attr(feature = "serde", serde(rename = "supportDistance"))]
130    pub m_supportDistance: f32,
131    /// # C++ Info
132    /// - name: `hardSupportDistance`(ctype: `hkReal`)
133    /// - offset: `100`(x86)/`116`(x86_64)
134    /// - type_size: `  4`(x86)/`  4`(x86_64)
135    #[cfg_attr(feature = "json_schema", schemars(rename = "hardSupportDistance"))]
136    #[cfg_attr(feature = "serde", serde(rename = "hardSupportDistance"))]
137    pub m_hardSupportDistance: f32,
138    /// # C++ Info
139    /// - name: `vdbColor`(ctype: `hkInt32`)
140    /// - offset: `104`(x86)/`120`(x86_64)
141    /// - type_size: `  4`(x86)/`  4`(x86_64)
142    #[cfg_attr(feature = "json_schema", schemars(rename = "vdbColor"))]
143    #[cfg_attr(feature = "serde", serde(rename = "vdbColor"))]
144    pub m_vdbColor: i32,
145}
146const _: () = {
147    use havok_serde as _serde;
148    impl _serde::HavokClass for hkpCharacterRigidBodyCinfo {
149        #[inline]
150        fn name(&self) -> &'static str {
151            "hkpCharacterRigidBodyCinfo"
152        }
153        #[inline]
154        fn signature(&self) -> _serde::__private::Signature {
155            _serde::__private::Signature::new(0x892f441)
156        }
157        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
158        fn deps_indexes(&self) -> Vec<usize> {
159            let mut v = Vec::new();
160            v.push(self.m_shape.get());
161            v
162        }
163    }
164    impl _serde::Serialize for hkpCharacterRigidBodyCinfo {
165        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
166        where
167            S: _serde::ser::Serializer,
168        {
169            let class_meta = self
170                .__ptr
171                .map(|name| (name, _serde::__private::Signature::new(0x892f441)));
172            let mut serializer = __serializer
173                .serialize_struct(
174                    "hkpCharacterRigidBodyCinfo",
175                    class_meta,
176                    (112u64, 128u64),
177                )?;
178            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
179            serializer
180                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
181            serializer
182                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
183            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
184            serializer
185                .serialize_field("collisionFilterInfo", &self.m_collisionFilterInfo)?;
186            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
187            serializer.serialize_field("shape", &self.m_shape)?;
188            serializer.serialize_field("position", &self.m_position)?;
189            serializer.serialize_field("rotation", &self.m_rotation)?;
190            serializer.serialize_field("mass", &self.m_mass)?;
191            serializer.serialize_field("friction", &self.m_friction)?;
192            serializer.serialize_field("maxLinearVelocity", &self.m_maxLinearVelocity)?;
193            serializer
194                .serialize_field(
195                    "allowedPenetrationDepth",
196                    &self.m_allowedPenetrationDepth,
197                )?;
198            serializer.serialize_field("up", &self.m_up)?;
199            serializer.serialize_field("maxSlope", &self.m_maxSlope)?;
200            serializer.serialize_field("maxForce", &self.m_maxForce)?;
201            serializer
202                .serialize_field(
203                    "unweldingHeightOffsetFactor",
204                    &self.m_unweldingHeightOffsetFactor,
205                )?;
206            serializer
207                .serialize_field(
208                    "maxSpeedForSimplexSolver",
209                    &self.m_maxSpeedForSimplexSolver,
210                )?;
211            serializer.serialize_field("supportDistance", &self.m_supportDistance)?;
212            serializer
213                .serialize_field("hardSupportDistance", &self.m_hardSupportDistance)?;
214            serializer.serialize_field("vdbColor", &self.m_vdbColor)?;
215            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 4usize].as_slice())?;
216            serializer.end()
217        }
218    }
219};
220#[doc(hidden)]
221#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
222const _: () = {
223    use havok_serde as _serde;
224    #[automatically_derived]
225    impl<'de> _serde::Deserialize<'de> for hkpCharacterRigidBodyCinfo {
226        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
227        where
228            __D: _serde::Deserializer<'de>,
229        {
230            #[allow(non_camel_case_types)]
231            enum __Field {
232                m_collisionFilterInfo,
233                m_shape,
234                m_position,
235                m_rotation,
236                m_mass,
237                m_friction,
238                m_maxLinearVelocity,
239                m_allowedPenetrationDepth,
240                m_up,
241                m_maxSlope,
242                m_maxForce,
243                m_unweldingHeightOffsetFactor,
244                m_maxSpeedForSimplexSolver,
245                m_supportDistance,
246                m_hardSupportDistance,
247                m_vdbColor,
248                __ignore,
249            }
250            struct __FieldVisitor;
251            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
252                type Value = __Field;
253                fn expecting(
254                    &self,
255                    __formatter: &mut core::fmt::Formatter,
256                ) -> core::fmt::Result {
257                    core::fmt::Formatter::write_str(__formatter, "field identifier")
258                }
259                /// Intended for use in XML.
260                #[allow(clippy::match_single_binding)]
261                #[allow(clippy::reversed_empty_ranges)]
262                #[allow(clippy::single_match)]
263                fn visit_key<__E>(
264                    self,
265                    __value: &str,
266                ) -> core::result::Result<Self::Value, __E>
267                where
268                    __E: _serde::de::Error,
269                {
270                    match __value {
271                        "collisionFilterInfo" => Ok(__Field::m_collisionFilterInfo),
272                        "shape" => Ok(__Field::m_shape),
273                        "position" => Ok(__Field::m_position),
274                        "rotation" => Ok(__Field::m_rotation),
275                        "mass" => Ok(__Field::m_mass),
276                        "friction" => Ok(__Field::m_friction),
277                        "maxLinearVelocity" => Ok(__Field::m_maxLinearVelocity),
278                        "allowedPenetrationDepth" => {
279                            Ok(__Field::m_allowedPenetrationDepth)
280                        }
281                        "up" => Ok(__Field::m_up),
282                        "maxSlope" => Ok(__Field::m_maxSlope),
283                        "maxForce" => Ok(__Field::m_maxForce),
284                        "unweldingHeightOffsetFactor" => {
285                            Ok(__Field::m_unweldingHeightOffsetFactor)
286                        }
287                        "maxSpeedForSimplexSolver" => {
288                            Ok(__Field::m_maxSpeedForSimplexSolver)
289                        }
290                        "supportDistance" => Ok(__Field::m_supportDistance),
291                        "hardSupportDistance" => Ok(__Field::m_hardSupportDistance),
292                        "vdbColor" => Ok(__Field::m_vdbColor),
293                        _ => Ok(__Field::__ignore),
294                    }
295                }
296            }
297            impl<'de> _serde::Deserialize<'de> for __Field {
298                #[inline]
299                fn deserialize<__D>(
300                    __deserializer: __D,
301                ) -> core::result::Result<Self, __D::Error>
302                where
303                    __D: _serde::Deserializer<'de>,
304                {
305                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
306                }
307            }
308            struct __hkpCharacterRigidBodyCinfoVisitor<'de> {
309                marker: _serde::__private::PhantomData<hkpCharacterRigidBodyCinfo>,
310                lifetime: _serde::__private::PhantomData<&'de ()>,
311            }
312            #[allow(clippy::match_single_binding)]
313            #[allow(clippy::reversed_empty_ranges)]
314            #[allow(clippy::single_match)]
315            impl<'de> _serde::de::Visitor<'de>
316            for __hkpCharacterRigidBodyCinfoVisitor<'de> {
317                type Value = hkpCharacterRigidBodyCinfo;
318                fn expecting(
319                    &self,
320                    __formatter: &mut core::fmt::Formatter,
321                ) -> core::fmt::Result {
322                    core::fmt::Formatter::write_str(
323                        __formatter,
324                        "struct hkpCharacterRigidBodyCinfo",
325                    )
326                }
327                fn visit_struct_for_bytes<__A>(
328                    self,
329                    mut __map: __A,
330                ) -> _serde::__private::Result<Self::Value, __A::Error>
331                where
332                    __A: _serde::de::MapAccess<'de>,
333                {
334                    let __ptr = __A::class_ptr(&mut __map);
335                    let parent = __A::parent_value(&mut __map)?;
336                    let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
337                    let mut m_shape: _serde::__private::Option<Pointer> = _serde::__private::None;
338                    let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
339                    let mut m_rotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
340                    let mut m_mass: _serde::__private::Option<f32> = _serde::__private::None;
341                    let mut m_friction: _serde::__private::Option<f32> = _serde::__private::None;
342                    let mut m_maxLinearVelocity: _serde::__private::Option<f32> = _serde::__private::None;
343                    let mut m_allowedPenetrationDepth: _serde::__private::Option<f32> = _serde::__private::None;
344                    let mut m_up: _serde::__private::Option<Vector4> = _serde::__private::None;
345                    let mut m_maxSlope: _serde::__private::Option<f32> = _serde::__private::None;
346                    let mut m_maxForce: _serde::__private::Option<f32> = _serde::__private::None;
347                    let mut m_unweldingHeightOffsetFactor: _serde::__private::Option<
348                        f32,
349                    > = _serde::__private::None;
350                    let mut m_maxSpeedForSimplexSolver: _serde::__private::Option<f32> = _serde::__private::None;
351                    let mut m_supportDistance: _serde::__private::Option<f32> = _serde::__private::None;
352                    let mut m_hardSupportDistance: _serde::__private::Option<f32> = _serde::__private::None;
353                    let mut m_vdbColor: _serde::__private::Option<i32> = _serde::__private::None;
354                    for i in 0..16usize {
355                        match i {
356                            0usize => {
357                                if _serde::__private::Option::is_some(
358                                    &m_collisionFilterInfo,
359                                ) {
360                                    return _serde::__private::Err(
361                                        <__A::Error as _serde::de::Error>::duplicate_field(
362                                            "collisionFilterInfo",
363                                        ),
364                                    );
365                                }
366                                m_collisionFilterInfo = _serde::__private::Some(
367                                    match __A::next_value::<u32>(&mut __map) {
368                                        _serde::__private::Ok(__val) => __val,
369                                        _serde::__private::Err(__err) => {
370                                            return _serde::__private::Err(__err);
371                                        }
372                                    },
373                                );
374                            }
375                            1usize => {
376                                if _serde::__private::Option::is_some(&m_shape) {
377                                    return _serde::__private::Err(
378                                        <__A::Error as _serde::de::Error>::duplicate_field("shape"),
379                                    );
380                                }
381                                __A::pad(&mut __map, 0usize, 4usize)?;
382                                m_shape = _serde::__private::Some(
383                                    match __A::next_value::<Pointer>(&mut __map) {
384                                        _serde::__private::Ok(__val) => __val,
385                                        _serde::__private::Err(__err) => {
386                                            return _serde::__private::Err(__err);
387                                        }
388                                    },
389                                );
390                            }
391                            2usize => {
392                                if _serde::__private::Option::is_some(&m_position) {
393                                    return _serde::__private::Err(
394                                        <__A::Error as _serde::de::Error>::duplicate_field(
395                                            "position",
396                                        ),
397                                    );
398                                }
399                                m_position = _serde::__private::Some(
400                                    match __A::next_value::<Vector4>(&mut __map) {
401                                        _serde::__private::Ok(__val) => __val,
402                                        _serde::__private::Err(__err) => {
403                                            return _serde::__private::Err(__err);
404                                        }
405                                    },
406                                );
407                            }
408                            3usize => {
409                                if _serde::__private::Option::is_some(&m_rotation) {
410                                    return _serde::__private::Err(
411                                        <__A::Error as _serde::de::Error>::duplicate_field(
412                                            "rotation",
413                                        ),
414                                    );
415                                }
416                                m_rotation = _serde::__private::Some(
417                                    match __A::next_value::<Quaternion>(&mut __map) {
418                                        _serde::__private::Ok(__val) => __val,
419                                        _serde::__private::Err(__err) => {
420                                            return _serde::__private::Err(__err);
421                                        }
422                                    },
423                                );
424                            }
425                            4usize => {
426                                if _serde::__private::Option::is_some(&m_mass) {
427                                    return _serde::__private::Err(
428                                        <__A::Error as _serde::de::Error>::duplicate_field("mass"),
429                                    );
430                                }
431                                m_mass = _serde::__private::Some(
432                                    match __A::next_value::<f32>(&mut __map) {
433                                        _serde::__private::Ok(__val) => __val,
434                                        _serde::__private::Err(__err) => {
435                                            return _serde::__private::Err(__err);
436                                        }
437                                    },
438                                );
439                            }
440                            5usize => {
441                                if _serde::__private::Option::is_some(&m_friction) {
442                                    return _serde::__private::Err(
443                                        <__A::Error as _serde::de::Error>::duplicate_field(
444                                            "friction",
445                                        ),
446                                    );
447                                }
448                                m_friction = _serde::__private::Some(
449                                    match __A::next_value::<f32>(&mut __map) {
450                                        _serde::__private::Ok(__val) => __val,
451                                        _serde::__private::Err(__err) => {
452                                            return _serde::__private::Err(__err);
453                                        }
454                                    },
455                                );
456                            }
457                            6usize => {
458                                if _serde::__private::Option::is_some(
459                                    &m_maxLinearVelocity,
460                                ) {
461                                    return _serde::__private::Err(
462                                        <__A::Error as _serde::de::Error>::duplicate_field(
463                                            "maxLinearVelocity",
464                                        ),
465                                    );
466                                }
467                                m_maxLinearVelocity = _serde::__private::Some(
468                                    match __A::next_value::<f32>(&mut __map) {
469                                        _serde::__private::Ok(__val) => __val,
470                                        _serde::__private::Err(__err) => {
471                                            return _serde::__private::Err(__err);
472                                        }
473                                    },
474                                );
475                            }
476                            7usize => {
477                                if _serde::__private::Option::is_some(
478                                    &m_allowedPenetrationDepth,
479                                ) {
480                                    return _serde::__private::Err(
481                                        <__A::Error as _serde::de::Error>::duplicate_field(
482                                            "allowedPenetrationDepth",
483                                        ),
484                                    );
485                                }
486                                m_allowedPenetrationDepth = _serde::__private::Some(
487                                    match __A::next_value::<f32>(&mut __map) {
488                                        _serde::__private::Ok(__val) => __val,
489                                        _serde::__private::Err(__err) => {
490                                            return _serde::__private::Err(__err);
491                                        }
492                                    },
493                                );
494                            }
495                            8usize => {
496                                if _serde::__private::Option::is_some(&m_up) {
497                                    return _serde::__private::Err(
498                                        <__A::Error as _serde::de::Error>::duplicate_field("up"),
499                                    );
500                                }
501                                m_up = _serde::__private::Some(
502                                    match __A::next_value::<Vector4>(&mut __map) {
503                                        _serde::__private::Ok(__val) => __val,
504                                        _serde::__private::Err(__err) => {
505                                            return _serde::__private::Err(__err);
506                                        }
507                                    },
508                                );
509                            }
510                            9usize => {
511                                if _serde::__private::Option::is_some(&m_maxSlope) {
512                                    return _serde::__private::Err(
513                                        <__A::Error as _serde::de::Error>::duplicate_field(
514                                            "maxSlope",
515                                        ),
516                                    );
517                                }
518                                m_maxSlope = _serde::__private::Some(
519                                    match __A::next_value::<f32>(&mut __map) {
520                                        _serde::__private::Ok(__val) => __val,
521                                        _serde::__private::Err(__err) => {
522                                            return _serde::__private::Err(__err);
523                                        }
524                                    },
525                                );
526                            }
527                            10usize => {
528                                if _serde::__private::Option::is_some(&m_maxForce) {
529                                    return _serde::__private::Err(
530                                        <__A::Error as _serde::de::Error>::duplicate_field(
531                                            "maxForce",
532                                        ),
533                                    );
534                                }
535                                m_maxForce = _serde::__private::Some(
536                                    match __A::next_value::<f32>(&mut __map) {
537                                        _serde::__private::Ok(__val) => __val,
538                                        _serde::__private::Err(__err) => {
539                                            return _serde::__private::Err(__err);
540                                        }
541                                    },
542                                );
543                            }
544                            11usize => {
545                                if _serde::__private::Option::is_some(
546                                    &m_unweldingHeightOffsetFactor,
547                                ) {
548                                    return _serde::__private::Err(
549                                        <__A::Error as _serde::de::Error>::duplicate_field(
550                                            "unweldingHeightOffsetFactor",
551                                        ),
552                                    );
553                                }
554                                m_unweldingHeightOffsetFactor = _serde::__private::Some(
555                                    match __A::next_value::<f32>(&mut __map) {
556                                        _serde::__private::Ok(__val) => __val,
557                                        _serde::__private::Err(__err) => {
558                                            return _serde::__private::Err(__err);
559                                        }
560                                    },
561                                );
562                            }
563                            12usize => {
564                                if _serde::__private::Option::is_some(
565                                    &m_maxSpeedForSimplexSolver,
566                                ) {
567                                    return _serde::__private::Err(
568                                        <__A::Error as _serde::de::Error>::duplicate_field(
569                                            "maxSpeedForSimplexSolver",
570                                        ),
571                                    );
572                                }
573                                m_maxSpeedForSimplexSolver = _serde::__private::Some(
574                                    match __A::next_value::<f32>(&mut __map) {
575                                        _serde::__private::Ok(__val) => __val,
576                                        _serde::__private::Err(__err) => {
577                                            return _serde::__private::Err(__err);
578                                        }
579                                    },
580                                );
581                            }
582                            13usize => {
583                                if _serde::__private::Option::is_some(&m_supportDistance) {
584                                    return _serde::__private::Err(
585                                        <__A::Error as _serde::de::Error>::duplicate_field(
586                                            "supportDistance",
587                                        ),
588                                    );
589                                }
590                                m_supportDistance = _serde::__private::Some(
591                                    match __A::next_value::<f32>(&mut __map) {
592                                        _serde::__private::Ok(__val) => __val,
593                                        _serde::__private::Err(__err) => {
594                                            return _serde::__private::Err(__err);
595                                        }
596                                    },
597                                );
598                            }
599                            14usize => {
600                                if _serde::__private::Option::is_some(
601                                    &m_hardSupportDistance,
602                                ) {
603                                    return _serde::__private::Err(
604                                        <__A::Error as _serde::de::Error>::duplicate_field(
605                                            "hardSupportDistance",
606                                        ),
607                                    );
608                                }
609                                m_hardSupportDistance = _serde::__private::Some(
610                                    match __A::next_value::<f32>(&mut __map) {
611                                        _serde::__private::Ok(__val) => __val,
612                                        _serde::__private::Err(__err) => {
613                                            return _serde::__private::Err(__err);
614                                        }
615                                    },
616                                );
617                            }
618                            15usize => {
619                                if _serde::__private::Option::is_some(&m_vdbColor) {
620                                    return _serde::__private::Err(
621                                        <__A::Error as _serde::de::Error>::duplicate_field(
622                                            "vdbColor",
623                                        ),
624                                    );
625                                }
626                                m_vdbColor = _serde::__private::Some(
627                                    match __A::next_value::<i32>(&mut __map) {
628                                        _serde::__private::Ok(__val) => __val,
629                                        _serde::__private::Err(__err) => {
630                                            return _serde::__private::Err(__err);
631                                        }
632                                    },
633                                );
634                            }
635                            _ => {}
636                        }
637                    }
638                    __A::pad(&mut __map, 4usize, 4usize)?;
639                    let m_collisionFilterInfo = match m_collisionFilterInfo {
640                        _serde::__private::Some(__field) => __field,
641                        _serde::__private::None => {
642                            return _serde::__private::Err(
643                                <__A::Error as _serde::de::Error>::missing_field(
644                                    "collisionFilterInfo",
645                                ),
646                            );
647                        }
648                    };
649                    let m_shape = match m_shape {
650                        _serde::__private::Some(__field) => __field,
651                        _serde::__private::None => {
652                            return _serde::__private::Err(
653                                <__A::Error as _serde::de::Error>::missing_field("shape"),
654                            );
655                        }
656                    };
657                    let m_position = match m_position {
658                        _serde::__private::Some(__field) => __field,
659                        _serde::__private::None => {
660                            return _serde::__private::Err(
661                                <__A::Error as _serde::de::Error>::missing_field("position"),
662                            );
663                        }
664                    };
665                    let m_rotation = match m_rotation {
666                        _serde::__private::Some(__field) => __field,
667                        _serde::__private::None => {
668                            return _serde::__private::Err(
669                                <__A::Error as _serde::de::Error>::missing_field("rotation"),
670                            );
671                        }
672                    };
673                    let m_mass = match m_mass {
674                        _serde::__private::Some(__field) => __field,
675                        _serde::__private::None => {
676                            return _serde::__private::Err(
677                                <__A::Error as _serde::de::Error>::missing_field("mass"),
678                            );
679                        }
680                    };
681                    let m_friction = match m_friction {
682                        _serde::__private::Some(__field) => __field,
683                        _serde::__private::None => {
684                            return _serde::__private::Err(
685                                <__A::Error as _serde::de::Error>::missing_field("friction"),
686                            );
687                        }
688                    };
689                    let m_maxLinearVelocity = match m_maxLinearVelocity {
690                        _serde::__private::Some(__field) => __field,
691                        _serde::__private::None => {
692                            return _serde::__private::Err(
693                                <__A::Error as _serde::de::Error>::missing_field(
694                                    "maxLinearVelocity",
695                                ),
696                            );
697                        }
698                    };
699                    let m_allowedPenetrationDepth = match m_allowedPenetrationDepth {
700                        _serde::__private::Some(__field) => __field,
701                        _serde::__private::None => {
702                            return _serde::__private::Err(
703                                <__A::Error as _serde::de::Error>::missing_field(
704                                    "allowedPenetrationDepth",
705                                ),
706                            );
707                        }
708                    };
709                    let m_up = match m_up {
710                        _serde::__private::Some(__field) => __field,
711                        _serde::__private::None => {
712                            return _serde::__private::Err(
713                                <__A::Error as _serde::de::Error>::missing_field("up"),
714                            );
715                        }
716                    };
717                    let m_maxSlope = match m_maxSlope {
718                        _serde::__private::Some(__field) => __field,
719                        _serde::__private::None => {
720                            return _serde::__private::Err(
721                                <__A::Error as _serde::de::Error>::missing_field("maxSlope"),
722                            );
723                        }
724                    };
725                    let m_maxForce = match m_maxForce {
726                        _serde::__private::Some(__field) => __field,
727                        _serde::__private::None => {
728                            return _serde::__private::Err(
729                                <__A::Error as _serde::de::Error>::missing_field("maxForce"),
730                            );
731                        }
732                    };
733                    let m_unweldingHeightOffsetFactor = match m_unweldingHeightOffsetFactor {
734                        _serde::__private::Some(__field) => __field,
735                        _serde::__private::None => {
736                            return _serde::__private::Err(
737                                <__A::Error as _serde::de::Error>::missing_field(
738                                    "unweldingHeightOffsetFactor",
739                                ),
740                            );
741                        }
742                    };
743                    let m_maxSpeedForSimplexSolver = match m_maxSpeedForSimplexSolver {
744                        _serde::__private::Some(__field) => __field,
745                        _serde::__private::None => {
746                            return _serde::__private::Err(
747                                <__A::Error as _serde::de::Error>::missing_field(
748                                    "maxSpeedForSimplexSolver",
749                                ),
750                            );
751                        }
752                    };
753                    let m_supportDistance = match m_supportDistance {
754                        _serde::__private::Some(__field) => __field,
755                        _serde::__private::None => {
756                            return _serde::__private::Err(
757                                <__A::Error as _serde::de::Error>::missing_field(
758                                    "supportDistance",
759                                ),
760                            );
761                        }
762                    };
763                    let m_hardSupportDistance = match m_hardSupportDistance {
764                        _serde::__private::Some(__field) => __field,
765                        _serde::__private::None => {
766                            return _serde::__private::Err(
767                                <__A::Error as _serde::de::Error>::missing_field(
768                                    "hardSupportDistance",
769                                ),
770                            );
771                        }
772                    };
773                    let m_vdbColor = match m_vdbColor {
774                        _serde::__private::Some(__field) => __field,
775                        _serde::__private::None => {
776                            return _serde::__private::Err(
777                                <__A::Error as _serde::de::Error>::missing_field("vdbColor"),
778                            );
779                        }
780                    };
781                    _serde::__private::Ok(hkpCharacterRigidBodyCinfo {
782                        __ptr,
783                        parent,
784                        m_collisionFilterInfo,
785                        m_shape,
786                        m_position,
787                        m_rotation,
788                        m_mass,
789                        m_friction,
790                        m_maxLinearVelocity,
791                        m_allowedPenetrationDepth,
792                        m_up,
793                        m_maxSlope,
794                        m_maxForce,
795                        m_unweldingHeightOffsetFactor,
796                        m_maxSpeedForSimplexSolver,
797                        m_supportDistance,
798                        m_hardSupportDistance,
799                        m_vdbColor,
800                    })
801                }
802                #[allow(clippy::manual_unwrap_or_default)]
803                fn visit_struct<__A>(
804                    self,
805                    mut __map: __A,
806                ) -> _serde::__private::Result<Self::Value, __A::Error>
807                where
808                    __A: _serde::de::MapAccess<'de>,
809                {
810                    let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
811                    let mut m_shape: _serde::__private::Option<Pointer> = _serde::__private::None;
812                    let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
813                    let mut m_rotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
814                    let mut m_mass: _serde::__private::Option<f32> = _serde::__private::None;
815                    let mut m_friction: _serde::__private::Option<f32> = _serde::__private::None;
816                    let mut m_maxLinearVelocity: _serde::__private::Option<f32> = _serde::__private::None;
817                    let mut m_allowedPenetrationDepth: _serde::__private::Option<f32> = _serde::__private::None;
818                    let mut m_up: _serde::__private::Option<Vector4> = _serde::__private::None;
819                    let mut m_maxSlope: _serde::__private::Option<f32> = _serde::__private::None;
820                    let mut m_maxForce: _serde::__private::Option<f32> = _serde::__private::None;
821                    let mut m_unweldingHeightOffsetFactor: _serde::__private::Option<
822                        f32,
823                    > = _serde::__private::None;
824                    let mut m_maxSpeedForSimplexSolver: _serde::__private::Option<f32> = _serde::__private::None;
825                    let mut m_supportDistance: _serde::__private::Option<f32> = _serde::__private::None;
826                    let mut m_hardSupportDistance: _serde::__private::Option<f32> = _serde::__private::None;
827                    let mut m_vdbColor: _serde::__private::Option<i32> = _serde::__private::None;
828                    while let _serde::__private::Some(__key) = {
829                        __A::next_key::<__Field>(&mut __map)?
830                    } {
831                        match __key {
832                            __Field::m_collisionFilterInfo => {
833                                #[cfg(
834                                    any(feature = "strict", feature = "ignore_duplicates")
835                                )]
836                                if _serde::__private::Option::is_some(
837                                    &m_collisionFilterInfo,
838                                ) {
839                                    #[cfg(feature = "ignore_duplicates")]
840                                    {
841                                        __A::skip_value(&mut __map)?;
842                                        continue;
843                                    }
844                                    #[cfg(feature = "strict")]
845                                    return _serde::__private::Err(
846                                        <__A::Error as _serde::de::Error>::duplicate_field(
847                                            "collisionFilterInfo",
848                                        ),
849                                    );
850                                }
851                                m_collisionFilterInfo = _serde::__private::Some(
852                                    match __A::next_value::<u32>(&mut __map) {
853                                        _serde::__private::Ok(__val) => __val,
854                                        _serde::__private::Err(__err) => {
855                                            return _serde::__private::Err(__err);
856                                        }
857                                    },
858                                );
859                            }
860                            __Field::m_shape => {
861                                #[cfg(
862                                    any(feature = "strict", feature = "ignore_duplicates")
863                                )]
864                                if _serde::__private::Option::is_some(&m_shape) {
865                                    #[cfg(feature = "ignore_duplicates")]
866                                    {
867                                        __A::skip_value(&mut __map)?;
868                                        continue;
869                                    }
870                                    #[cfg(feature = "strict")]
871                                    return _serde::__private::Err(
872                                        <__A::Error as _serde::de::Error>::duplicate_field("shape"),
873                                    );
874                                }
875                                m_shape = _serde::__private::Some(
876                                    match __A::next_value::<Pointer>(&mut __map) {
877                                        _serde::__private::Ok(__val) => __val,
878                                        _serde::__private::Err(__err) => {
879                                            return _serde::__private::Err(__err);
880                                        }
881                                    },
882                                );
883                            }
884                            __Field::m_position => {
885                                #[cfg(
886                                    any(feature = "strict", feature = "ignore_duplicates")
887                                )]
888                                if _serde::__private::Option::is_some(&m_position) {
889                                    #[cfg(feature = "ignore_duplicates")]
890                                    {
891                                        __A::skip_value(&mut __map)?;
892                                        continue;
893                                    }
894                                    #[cfg(feature = "strict")]
895                                    return _serde::__private::Err(
896                                        <__A::Error as _serde::de::Error>::duplicate_field(
897                                            "position",
898                                        ),
899                                    );
900                                }
901                                m_position = _serde::__private::Some(
902                                    match __A::next_value::<Vector4>(&mut __map) {
903                                        _serde::__private::Ok(__val) => __val,
904                                        _serde::__private::Err(__err) => {
905                                            return _serde::__private::Err(__err);
906                                        }
907                                    },
908                                );
909                            }
910                            __Field::m_rotation => {
911                                #[cfg(
912                                    any(feature = "strict", feature = "ignore_duplicates")
913                                )]
914                                if _serde::__private::Option::is_some(&m_rotation) {
915                                    #[cfg(feature = "ignore_duplicates")]
916                                    {
917                                        __A::skip_value(&mut __map)?;
918                                        continue;
919                                    }
920                                    #[cfg(feature = "strict")]
921                                    return _serde::__private::Err(
922                                        <__A::Error as _serde::de::Error>::duplicate_field(
923                                            "rotation",
924                                        ),
925                                    );
926                                }
927                                m_rotation = _serde::__private::Some(
928                                    match __A::next_value::<Quaternion>(&mut __map) {
929                                        _serde::__private::Ok(__val) => __val,
930                                        _serde::__private::Err(__err) => {
931                                            return _serde::__private::Err(__err);
932                                        }
933                                    },
934                                );
935                            }
936                            __Field::m_mass => {
937                                #[cfg(
938                                    any(feature = "strict", feature = "ignore_duplicates")
939                                )]
940                                if _serde::__private::Option::is_some(&m_mass) {
941                                    #[cfg(feature = "ignore_duplicates")]
942                                    {
943                                        __A::skip_value(&mut __map)?;
944                                        continue;
945                                    }
946                                    #[cfg(feature = "strict")]
947                                    return _serde::__private::Err(
948                                        <__A::Error as _serde::de::Error>::duplicate_field("mass"),
949                                    );
950                                }
951                                m_mass = _serde::__private::Some(
952                                    match __A::next_value::<f32>(&mut __map) {
953                                        _serde::__private::Ok(__val) => __val,
954                                        _serde::__private::Err(__err) => {
955                                            return _serde::__private::Err(__err);
956                                        }
957                                    },
958                                );
959                            }
960                            __Field::m_friction => {
961                                #[cfg(
962                                    any(feature = "strict", feature = "ignore_duplicates")
963                                )]
964                                if _serde::__private::Option::is_some(&m_friction) {
965                                    #[cfg(feature = "ignore_duplicates")]
966                                    {
967                                        __A::skip_value(&mut __map)?;
968                                        continue;
969                                    }
970                                    #[cfg(feature = "strict")]
971                                    return _serde::__private::Err(
972                                        <__A::Error as _serde::de::Error>::duplicate_field(
973                                            "friction",
974                                        ),
975                                    );
976                                }
977                                m_friction = _serde::__private::Some(
978                                    match __A::next_value::<f32>(&mut __map) {
979                                        _serde::__private::Ok(__val) => __val,
980                                        _serde::__private::Err(__err) => {
981                                            return _serde::__private::Err(__err);
982                                        }
983                                    },
984                                );
985                            }
986                            __Field::m_maxLinearVelocity => {
987                                #[cfg(
988                                    any(feature = "strict", feature = "ignore_duplicates")
989                                )]
990                                if _serde::__private::Option::is_some(
991                                    &m_maxLinearVelocity,
992                                ) {
993                                    #[cfg(feature = "ignore_duplicates")]
994                                    {
995                                        __A::skip_value(&mut __map)?;
996                                        continue;
997                                    }
998                                    #[cfg(feature = "strict")]
999                                    return _serde::__private::Err(
1000                                        <__A::Error as _serde::de::Error>::duplicate_field(
1001                                            "maxLinearVelocity",
1002                                        ),
1003                                    );
1004                                }
1005                                m_maxLinearVelocity = _serde::__private::Some(
1006                                    match __A::next_value::<f32>(&mut __map) {
1007                                        _serde::__private::Ok(__val) => __val,
1008                                        _serde::__private::Err(__err) => {
1009                                            return _serde::__private::Err(__err);
1010                                        }
1011                                    },
1012                                );
1013                            }
1014                            __Field::m_allowedPenetrationDepth => {
1015                                #[cfg(
1016                                    any(feature = "strict", feature = "ignore_duplicates")
1017                                )]
1018                                if _serde::__private::Option::is_some(
1019                                    &m_allowedPenetrationDepth,
1020                                ) {
1021                                    #[cfg(feature = "ignore_duplicates")]
1022                                    {
1023                                        __A::skip_value(&mut __map)?;
1024                                        continue;
1025                                    }
1026                                    #[cfg(feature = "strict")]
1027                                    return _serde::__private::Err(
1028                                        <__A::Error as _serde::de::Error>::duplicate_field(
1029                                            "allowedPenetrationDepth",
1030                                        ),
1031                                    );
1032                                }
1033                                m_allowedPenetrationDepth = _serde::__private::Some(
1034                                    match __A::next_value::<f32>(&mut __map) {
1035                                        _serde::__private::Ok(__val) => __val,
1036                                        _serde::__private::Err(__err) => {
1037                                            return _serde::__private::Err(__err);
1038                                        }
1039                                    },
1040                                );
1041                            }
1042                            __Field::m_up => {
1043                                #[cfg(
1044                                    any(feature = "strict", feature = "ignore_duplicates")
1045                                )]
1046                                if _serde::__private::Option::is_some(&m_up) {
1047                                    #[cfg(feature = "ignore_duplicates")]
1048                                    {
1049                                        __A::skip_value(&mut __map)?;
1050                                        continue;
1051                                    }
1052                                    #[cfg(feature = "strict")]
1053                                    return _serde::__private::Err(
1054                                        <__A::Error as _serde::de::Error>::duplicate_field("up"),
1055                                    );
1056                                }
1057                                m_up = _serde::__private::Some(
1058                                    match __A::next_value::<Vector4>(&mut __map) {
1059                                        _serde::__private::Ok(__val) => __val,
1060                                        _serde::__private::Err(__err) => {
1061                                            return _serde::__private::Err(__err);
1062                                        }
1063                                    },
1064                                );
1065                            }
1066                            __Field::m_maxSlope => {
1067                                #[cfg(
1068                                    any(feature = "strict", feature = "ignore_duplicates")
1069                                )]
1070                                if _serde::__private::Option::is_some(&m_maxSlope) {
1071                                    #[cfg(feature = "ignore_duplicates")]
1072                                    {
1073                                        __A::skip_value(&mut __map)?;
1074                                        continue;
1075                                    }
1076                                    #[cfg(feature = "strict")]
1077                                    return _serde::__private::Err(
1078                                        <__A::Error as _serde::de::Error>::duplicate_field(
1079                                            "maxSlope",
1080                                        ),
1081                                    );
1082                                }
1083                                m_maxSlope = _serde::__private::Some(
1084                                    match __A::next_value::<f32>(&mut __map) {
1085                                        _serde::__private::Ok(__val) => __val,
1086                                        _serde::__private::Err(__err) => {
1087                                            return _serde::__private::Err(__err);
1088                                        }
1089                                    },
1090                                );
1091                            }
1092                            __Field::m_maxForce => {
1093                                #[cfg(
1094                                    any(feature = "strict", feature = "ignore_duplicates")
1095                                )]
1096                                if _serde::__private::Option::is_some(&m_maxForce) {
1097                                    #[cfg(feature = "ignore_duplicates")]
1098                                    {
1099                                        __A::skip_value(&mut __map)?;
1100                                        continue;
1101                                    }
1102                                    #[cfg(feature = "strict")]
1103                                    return _serde::__private::Err(
1104                                        <__A::Error as _serde::de::Error>::duplicate_field(
1105                                            "maxForce",
1106                                        ),
1107                                    );
1108                                }
1109                                m_maxForce = _serde::__private::Some(
1110                                    match __A::next_value::<f32>(&mut __map) {
1111                                        _serde::__private::Ok(__val) => __val,
1112                                        _serde::__private::Err(__err) => {
1113                                            return _serde::__private::Err(__err);
1114                                        }
1115                                    },
1116                                );
1117                            }
1118                            __Field::m_unweldingHeightOffsetFactor => {
1119                                #[cfg(
1120                                    any(feature = "strict", feature = "ignore_duplicates")
1121                                )]
1122                                if _serde::__private::Option::is_some(
1123                                    &m_unweldingHeightOffsetFactor,
1124                                ) {
1125                                    #[cfg(feature = "ignore_duplicates")]
1126                                    {
1127                                        __A::skip_value(&mut __map)?;
1128                                        continue;
1129                                    }
1130                                    #[cfg(feature = "strict")]
1131                                    return _serde::__private::Err(
1132                                        <__A::Error as _serde::de::Error>::duplicate_field(
1133                                            "unweldingHeightOffsetFactor",
1134                                        ),
1135                                    );
1136                                }
1137                                m_unweldingHeightOffsetFactor = _serde::__private::Some(
1138                                    match __A::next_value::<f32>(&mut __map) {
1139                                        _serde::__private::Ok(__val) => __val,
1140                                        _serde::__private::Err(__err) => {
1141                                            return _serde::__private::Err(__err);
1142                                        }
1143                                    },
1144                                );
1145                            }
1146                            __Field::m_maxSpeedForSimplexSolver => {
1147                                #[cfg(
1148                                    any(feature = "strict", feature = "ignore_duplicates")
1149                                )]
1150                                if _serde::__private::Option::is_some(
1151                                    &m_maxSpeedForSimplexSolver,
1152                                ) {
1153                                    #[cfg(feature = "ignore_duplicates")]
1154                                    {
1155                                        __A::skip_value(&mut __map)?;
1156                                        continue;
1157                                    }
1158                                    #[cfg(feature = "strict")]
1159                                    return _serde::__private::Err(
1160                                        <__A::Error as _serde::de::Error>::duplicate_field(
1161                                            "maxSpeedForSimplexSolver",
1162                                        ),
1163                                    );
1164                                }
1165                                m_maxSpeedForSimplexSolver = _serde::__private::Some(
1166                                    match __A::next_value::<f32>(&mut __map) {
1167                                        _serde::__private::Ok(__val) => __val,
1168                                        _serde::__private::Err(__err) => {
1169                                            return _serde::__private::Err(__err);
1170                                        }
1171                                    },
1172                                );
1173                            }
1174                            __Field::m_supportDistance => {
1175                                #[cfg(
1176                                    any(feature = "strict", feature = "ignore_duplicates")
1177                                )]
1178                                if _serde::__private::Option::is_some(&m_supportDistance) {
1179                                    #[cfg(feature = "ignore_duplicates")]
1180                                    {
1181                                        __A::skip_value(&mut __map)?;
1182                                        continue;
1183                                    }
1184                                    #[cfg(feature = "strict")]
1185                                    return _serde::__private::Err(
1186                                        <__A::Error as _serde::de::Error>::duplicate_field(
1187                                            "supportDistance",
1188                                        ),
1189                                    );
1190                                }
1191                                m_supportDistance = _serde::__private::Some(
1192                                    match __A::next_value::<f32>(&mut __map) {
1193                                        _serde::__private::Ok(__val) => __val,
1194                                        _serde::__private::Err(__err) => {
1195                                            return _serde::__private::Err(__err);
1196                                        }
1197                                    },
1198                                );
1199                            }
1200                            __Field::m_hardSupportDistance => {
1201                                #[cfg(
1202                                    any(feature = "strict", feature = "ignore_duplicates")
1203                                )]
1204                                if _serde::__private::Option::is_some(
1205                                    &m_hardSupportDistance,
1206                                ) {
1207                                    #[cfg(feature = "ignore_duplicates")]
1208                                    {
1209                                        __A::skip_value(&mut __map)?;
1210                                        continue;
1211                                    }
1212                                    #[cfg(feature = "strict")]
1213                                    return _serde::__private::Err(
1214                                        <__A::Error as _serde::de::Error>::duplicate_field(
1215                                            "hardSupportDistance",
1216                                        ),
1217                                    );
1218                                }
1219                                m_hardSupportDistance = _serde::__private::Some(
1220                                    match __A::next_value::<f32>(&mut __map) {
1221                                        _serde::__private::Ok(__val) => __val,
1222                                        _serde::__private::Err(__err) => {
1223                                            return _serde::__private::Err(__err);
1224                                        }
1225                                    },
1226                                );
1227                            }
1228                            __Field::m_vdbColor => {
1229                                #[cfg(
1230                                    any(feature = "strict", feature = "ignore_duplicates")
1231                                )]
1232                                if _serde::__private::Option::is_some(&m_vdbColor) {
1233                                    #[cfg(feature = "ignore_duplicates")]
1234                                    {
1235                                        __A::skip_value(&mut __map)?;
1236                                        continue;
1237                                    }
1238                                    #[cfg(feature = "strict")]
1239                                    return _serde::__private::Err(
1240                                        <__A::Error as _serde::de::Error>::duplicate_field(
1241                                            "vdbColor",
1242                                        ),
1243                                    );
1244                                }
1245                                m_vdbColor = _serde::__private::Some(
1246                                    match __A::next_value::<i32>(&mut __map) {
1247                                        _serde::__private::Ok(__val) => __val,
1248                                        _serde::__private::Err(__err) => {
1249                                            return _serde::__private::Err(__err);
1250                                        }
1251                                    },
1252                                );
1253                            }
1254                            _ => __A::skip_value(&mut __map)?,
1255                        }
1256                    }
1257                    let m_collisionFilterInfo = match m_collisionFilterInfo {
1258                        _serde::__private::Some(__field) => __field,
1259                        _serde::__private::None => {
1260                            #[cfg(feature = "strict")]
1261                            return _serde::__private::Err(
1262                                <__A::Error as _serde::de::Error>::missing_field(
1263                                    "collisionFilterInfo",
1264                                ),
1265                            );
1266                            #[cfg(not(feature = "strict"))] Default::default()
1267                        }
1268                    };
1269                    let m_shape = match m_shape {
1270                        _serde::__private::Some(__field) => __field,
1271                        _serde::__private::None => {
1272                            #[cfg(feature = "strict")]
1273                            return _serde::__private::Err(
1274                                <__A::Error as _serde::de::Error>::missing_field("shape"),
1275                            );
1276                            #[cfg(not(feature = "strict"))] Default::default()
1277                        }
1278                    };
1279                    let m_position = match m_position {
1280                        _serde::__private::Some(__field) => __field,
1281                        _serde::__private::None => {
1282                            #[cfg(feature = "strict")]
1283                            return _serde::__private::Err(
1284                                <__A::Error as _serde::de::Error>::missing_field("position"),
1285                            );
1286                            #[cfg(not(feature = "strict"))] Default::default()
1287                        }
1288                    };
1289                    let m_rotation = match m_rotation {
1290                        _serde::__private::Some(__field) => __field,
1291                        _serde::__private::None => {
1292                            #[cfg(feature = "strict")]
1293                            return _serde::__private::Err(
1294                                <__A::Error as _serde::de::Error>::missing_field("rotation"),
1295                            );
1296                            #[cfg(not(feature = "strict"))] Default::default()
1297                        }
1298                    };
1299                    let m_mass = match m_mass {
1300                        _serde::__private::Some(__field) => __field,
1301                        _serde::__private::None => {
1302                            #[cfg(feature = "strict")]
1303                            return _serde::__private::Err(
1304                                <__A::Error as _serde::de::Error>::missing_field("mass"),
1305                            );
1306                            #[cfg(not(feature = "strict"))] Default::default()
1307                        }
1308                    };
1309                    let m_friction = match m_friction {
1310                        _serde::__private::Some(__field) => __field,
1311                        _serde::__private::None => {
1312                            #[cfg(feature = "strict")]
1313                            return _serde::__private::Err(
1314                                <__A::Error as _serde::de::Error>::missing_field("friction"),
1315                            );
1316                            #[cfg(not(feature = "strict"))] Default::default()
1317                        }
1318                    };
1319                    let m_maxLinearVelocity = match m_maxLinearVelocity {
1320                        _serde::__private::Some(__field) => __field,
1321                        _serde::__private::None => {
1322                            #[cfg(feature = "strict")]
1323                            return _serde::__private::Err(
1324                                <__A::Error as _serde::de::Error>::missing_field(
1325                                    "maxLinearVelocity",
1326                                ),
1327                            );
1328                            #[cfg(not(feature = "strict"))] Default::default()
1329                        }
1330                    };
1331                    let m_allowedPenetrationDepth = match m_allowedPenetrationDepth {
1332                        _serde::__private::Some(__field) => __field,
1333                        _serde::__private::None => {
1334                            #[cfg(feature = "strict")]
1335                            return _serde::__private::Err(
1336                                <__A::Error as _serde::de::Error>::missing_field(
1337                                    "allowedPenetrationDepth",
1338                                ),
1339                            );
1340                            #[cfg(not(feature = "strict"))] Default::default()
1341                        }
1342                    };
1343                    let m_up = match m_up {
1344                        _serde::__private::Some(__field) => __field,
1345                        _serde::__private::None => {
1346                            #[cfg(feature = "strict")]
1347                            return _serde::__private::Err(
1348                                <__A::Error as _serde::de::Error>::missing_field("up"),
1349                            );
1350                            #[cfg(not(feature = "strict"))] Default::default()
1351                        }
1352                    };
1353                    let m_maxSlope = match m_maxSlope {
1354                        _serde::__private::Some(__field) => __field,
1355                        _serde::__private::None => {
1356                            #[cfg(feature = "strict")]
1357                            return _serde::__private::Err(
1358                                <__A::Error as _serde::de::Error>::missing_field("maxSlope"),
1359                            );
1360                            #[cfg(not(feature = "strict"))] Default::default()
1361                        }
1362                    };
1363                    let m_maxForce = match m_maxForce {
1364                        _serde::__private::Some(__field) => __field,
1365                        _serde::__private::None => {
1366                            #[cfg(feature = "strict")]
1367                            return _serde::__private::Err(
1368                                <__A::Error as _serde::de::Error>::missing_field("maxForce"),
1369                            );
1370                            #[cfg(not(feature = "strict"))] Default::default()
1371                        }
1372                    };
1373                    let m_unweldingHeightOffsetFactor = match m_unweldingHeightOffsetFactor {
1374                        _serde::__private::Some(__field) => __field,
1375                        _serde::__private::None => {
1376                            #[cfg(feature = "strict")]
1377                            return _serde::__private::Err(
1378                                <__A::Error as _serde::de::Error>::missing_field(
1379                                    "unweldingHeightOffsetFactor",
1380                                ),
1381                            );
1382                            #[cfg(not(feature = "strict"))] Default::default()
1383                        }
1384                    };
1385                    let m_maxSpeedForSimplexSolver = match m_maxSpeedForSimplexSolver {
1386                        _serde::__private::Some(__field) => __field,
1387                        _serde::__private::None => {
1388                            #[cfg(feature = "strict")]
1389                            return _serde::__private::Err(
1390                                <__A::Error as _serde::de::Error>::missing_field(
1391                                    "maxSpeedForSimplexSolver",
1392                                ),
1393                            );
1394                            #[cfg(not(feature = "strict"))] Default::default()
1395                        }
1396                    };
1397                    let m_supportDistance = match m_supportDistance {
1398                        _serde::__private::Some(__field) => __field,
1399                        _serde::__private::None => {
1400                            #[cfg(feature = "strict")]
1401                            return _serde::__private::Err(
1402                                <__A::Error as _serde::de::Error>::missing_field(
1403                                    "supportDistance",
1404                                ),
1405                            );
1406                            #[cfg(not(feature = "strict"))] Default::default()
1407                        }
1408                    };
1409                    let m_hardSupportDistance = match m_hardSupportDistance {
1410                        _serde::__private::Some(__field) => __field,
1411                        _serde::__private::None => {
1412                            #[cfg(feature = "strict")]
1413                            return _serde::__private::Err(
1414                                <__A::Error as _serde::de::Error>::missing_field(
1415                                    "hardSupportDistance",
1416                                ),
1417                            );
1418                            #[cfg(not(feature = "strict"))] Default::default()
1419                        }
1420                    };
1421                    let m_vdbColor = match m_vdbColor {
1422                        _serde::__private::Some(__field) => __field,
1423                        _serde::__private::None => {
1424                            #[cfg(feature = "strict")]
1425                            return _serde::__private::Err(
1426                                <__A::Error as _serde::de::Error>::missing_field("vdbColor"),
1427                            );
1428                            #[cfg(not(feature = "strict"))] Default::default()
1429                        }
1430                    };
1431                    let __ptr = None;
1432                    let parent = hkBaseObject { __ptr };
1433                    let parent = hkReferencedObject {
1434                        __ptr,
1435                        parent,
1436                        ..Default::default()
1437                    };
1438                    let parent = hkpCharacterControllerCinfo {
1439                        __ptr,
1440                        parent,
1441                    };
1442                    let __ptr = __A::class_ptr(&mut __map);
1443                    _serde::__private::Ok(hkpCharacterRigidBodyCinfo {
1444                        __ptr,
1445                        parent,
1446                        m_collisionFilterInfo,
1447                        m_shape,
1448                        m_position,
1449                        m_rotation,
1450                        m_mass,
1451                        m_friction,
1452                        m_maxLinearVelocity,
1453                        m_allowedPenetrationDepth,
1454                        m_up,
1455                        m_maxSlope,
1456                        m_maxForce,
1457                        m_unweldingHeightOffsetFactor,
1458                        m_maxSpeedForSimplexSolver,
1459                        m_supportDistance,
1460                        m_hardSupportDistance,
1461                        m_vdbColor,
1462                    })
1463                }
1464            }
1465            const FIELDS: &[&str] = &[
1466                "collisionFilterInfo",
1467                "shape",
1468                "position",
1469                "rotation",
1470                "mass",
1471                "friction",
1472                "maxLinearVelocity",
1473                "allowedPenetrationDepth",
1474                "up",
1475                "maxSlope",
1476                "maxForce",
1477                "unweldingHeightOffsetFactor",
1478                "maxSpeedForSimplexSolver",
1479                "supportDistance",
1480                "hardSupportDistance",
1481                "vdbColor",
1482            ];
1483            _serde::Deserializer::deserialize_struct(
1484                deserializer,
1485                "hkpCharacterRigidBodyCinfo",
1486                FIELDS,
1487                __hkpCharacterRigidBodyCinfoVisitor {
1488                    marker: _serde::__private::PhantomData::<hkpCharacterRigidBodyCinfo>,
1489                    lifetime: _serde::__private::PhantomData,
1490                },
1491            )
1492        }
1493    }
1494};