havok_classes/generated/
hkpCharacterProxyCinfo_.rs

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