havok_classes/generated/
hkbProxyModifierProxyInfo_.rs

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