havok_classes/generated/
hkpWorldCinfo_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpWorldCinfo`
5/// - version: `11`
6/// - signature: `0xa5255445`
7/// - size: `240`(x86)/`256`(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 hkpWorldCinfo {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `gravity`(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 = "gravity"))]
35    #[cfg_attr(feature = "serde", serde(rename = "gravity"))]
36    pub m_gravity: Vector4,
37    /// # C++ Info
38    /// - name: `broadPhaseQuerySize`(ctype: `hkInt32`)
39    /// - offset: ` 32`(x86)/` 32`(x86_64)
40    /// - type_size: `  4`(x86)/`  4`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "broadPhaseQuerySize"))]
42    #[cfg_attr(feature = "serde", serde(rename = "broadPhaseQuerySize"))]
43    pub m_broadPhaseQuerySize: i32,
44    /// # C++ Info
45    /// - name: `contactRestingVelocity`(ctype: `hkReal`)
46    /// - offset: ` 36`(x86)/` 36`(x86_64)
47    /// - type_size: `  4`(x86)/`  4`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "contactRestingVelocity"))]
49    #[cfg_attr(feature = "serde", serde(rename = "contactRestingVelocity"))]
50    pub m_contactRestingVelocity: f32,
51    /// # C++ Info
52    /// - name: `broadPhaseBorderBehaviour`(ctype: `enum BroadPhaseBorderBehaviour`)
53    /// - offset: ` 40`(x86)/` 40`(x86_64)
54    /// - type_size: `  1`(x86)/`  1`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "broadPhaseBorderBehaviour"))]
56    #[cfg_attr(feature = "serde", serde(rename = "broadPhaseBorderBehaviour"))]
57    pub m_broadPhaseBorderBehaviour: BroadPhaseBorderBehaviour,
58    /// # C++ Info
59    /// - name: `mtPostponeAndSortBroadPhaseBorderCallbacks`(ctype: `hkBool`)
60    /// - offset: ` 41`(x86)/` 41`(x86_64)
61    /// - type_size: `  1`(x86)/`  1`(x86_64)
62    #[cfg_attr(
63        feature = "json_schema",
64        schemars(rename = "mtPostponeAndSortBroadPhaseBorderCallbacks")
65    )]
66    #[cfg_attr(
67        feature = "serde",
68        serde(rename = "mtPostponeAndSortBroadPhaseBorderCallbacks")
69    )]
70    pub m_mtPostponeAndSortBroadPhaseBorderCallbacks: bool,
71    /// # C++ Info
72    /// - name: `broadPhaseWorldAabb`(ctype: `struct hkAabb`)
73    /// - offset: ` 48`(x86)/` 48`(x86_64)
74    /// - type_size: ` 32`(x86)/` 32`(x86_64)
75    #[cfg_attr(feature = "json_schema", schemars(rename = "broadPhaseWorldAabb"))]
76    #[cfg_attr(feature = "serde", serde(rename = "broadPhaseWorldAabb"))]
77    pub m_broadPhaseWorldAabb: hkAabb,
78    /// # C++ Info
79    /// - name: `useKdTree`(ctype: `hkBool`)
80    /// - offset: ` 80`(x86)/` 80`(x86_64)
81    /// - type_size: `  1`(x86)/`  1`(x86_64)
82    #[cfg_attr(feature = "json_schema", schemars(rename = "useKdTree"))]
83    #[cfg_attr(feature = "serde", serde(rename = "useKdTree"))]
84    pub m_useKdTree: bool,
85    /// # C++ Info
86    /// - name: `useMultipleTree`(ctype: `hkBool`)
87    /// - offset: ` 81`(x86)/` 81`(x86_64)
88    /// - type_size: `  1`(x86)/`  1`(x86_64)
89    #[cfg_attr(feature = "json_schema", schemars(rename = "useMultipleTree"))]
90    #[cfg_attr(feature = "serde", serde(rename = "useMultipleTree"))]
91    pub m_useMultipleTree: bool,
92    /// # C++ Info
93    /// - name: `treeUpdateType`(ctype: `enum TreeUpdateType`)
94    /// - offset: ` 82`(x86)/` 82`(x86_64)
95    /// - type_size: `  1`(x86)/`  1`(x86_64)
96    #[cfg_attr(feature = "json_schema", schemars(rename = "treeUpdateType"))]
97    #[cfg_attr(feature = "serde", serde(rename = "treeUpdateType"))]
98    pub m_treeUpdateType: TreeUpdateType,
99    /// # C++ Info
100    /// - name: `autoUpdateKdTree`(ctype: `hkBool`)
101    /// - offset: ` 83`(x86)/` 83`(x86_64)
102    /// - type_size: `  1`(x86)/`  1`(x86_64)
103    #[cfg_attr(feature = "json_schema", schemars(rename = "autoUpdateKdTree"))]
104    #[cfg_attr(feature = "serde", serde(rename = "autoUpdateKdTree"))]
105    pub m_autoUpdateKdTree: bool,
106    /// # C++ Info
107    /// - name: `collisionTolerance`(ctype: `hkReal`)
108    /// - offset: ` 84`(x86)/` 84`(x86_64)
109    /// - type_size: `  4`(x86)/`  4`(x86_64)
110    #[cfg_attr(feature = "json_schema", schemars(rename = "collisionTolerance"))]
111    #[cfg_attr(feature = "serde", serde(rename = "collisionTolerance"))]
112    pub m_collisionTolerance: f32,
113    /// # C++ Info
114    /// - name: `collisionFilter`(ctype: `struct hkpCollisionFilter*`)
115    /// - offset: ` 88`(x86)/` 88`(x86_64)
116    /// - type_size: `  4`(x86)/`  8`(x86_64)
117    #[cfg_attr(feature = "json_schema", schemars(rename = "collisionFilter"))]
118    #[cfg_attr(feature = "serde", serde(rename = "collisionFilter"))]
119    pub m_collisionFilter: Pointer,
120    /// # C++ Info
121    /// - name: `convexListFilter`(ctype: `struct hkpConvexListFilter*`)
122    /// - offset: ` 92`(x86)/` 96`(x86_64)
123    /// - type_size: `  4`(x86)/`  8`(x86_64)
124    #[cfg_attr(feature = "json_schema", schemars(rename = "convexListFilter"))]
125    #[cfg_attr(feature = "serde", serde(rename = "convexListFilter"))]
126    pub m_convexListFilter: Pointer,
127    /// # C++ Info
128    /// - name: `expectedMaxLinearVelocity`(ctype: `hkReal`)
129    /// - offset: ` 96`(x86)/`104`(x86_64)
130    /// - type_size: `  4`(x86)/`  4`(x86_64)
131    #[cfg_attr(feature = "json_schema", schemars(rename = "expectedMaxLinearVelocity"))]
132    #[cfg_attr(feature = "serde", serde(rename = "expectedMaxLinearVelocity"))]
133    pub m_expectedMaxLinearVelocity: f32,
134    /// # C++ Info
135    /// - name: `sizeOfToiEventQueue`(ctype: `hkInt32`)
136    /// - offset: `100`(x86)/`108`(x86_64)
137    /// - type_size: `  4`(x86)/`  4`(x86_64)
138    #[cfg_attr(feature = "json_schema", schemars(rename = "sizeOfToiEventQueue"))]
139    #[cfg_attr(feature = "serde", serde(rename = "sizeOfToiEventQueue"))]
140    pub m_sizeOfToiEventQueue: i32,
141    /// # C++ Info
142    /// - name: `expectedMinPsiDeltaTime`(ctype: `hkReal`)
143    /// - offset: `104`(x86)/`112`(x86_64)
144    /// - type_size: `  4`(x86)/`  4`(x86_64)
145    #[cfg_attr(feature = "json_schema", schemars(rename = "expectedMinPsiDeltaTime"))]
146    #[cfg_attr(feature = "serde", serde(rename = "expectedMinPsiDeltaTime"))]
147    pub m_expectedMinPsiDeltaTime: f32,
148    /// # C++ Info
149    /// - name: `memoryWatchDog`(ctype: `struct hkWorldMemoryAvailableWatchDog*`)
150    /// - offset: `108`(x86)/`120`(x86_64)
151    /// - type_size: `  4`(x86)/`  8`(x86_64)
152    #[cfg_attr(feature = "json_schema", schemars(rename = "memoryWatchDog"))]
153    #[cfg_attr(feature = "serde", serde(rename = "memoryWatchDog"))]
154    pub m_memoryWatchDog: Pointer,
155    /// # C++ Info
156    /// - name: `broadPhaseNumMarkers`(ctype: `hkInt32`)
157    /// - offset: `112`(x86)/`128`(x86_64)
158    /// - type_size: `  4`(x86)/`  4`(x86_64)
159    #[cfg_attr(feature = "json_schema", schemars(rename = "broadPhaseNumMarkers"))]
160    #[cfg_attr(feature = "serde", serde(rename = "broadPhaseNumMarkers"))]
161    pub m_broadPhaseNumMarkers: i32,
162    /// # C++ Info
163    /// - name: `contactPointGeneration`(ctype: `enum ContactPointGeneration`)
164    /// - offset: `116`(x86)/`132`(x86_64)
165    /// - type_size: `  1`(x86)/`  1`(x86_64)
166    #[cfg_attr(feature = "json_schema", schemars(rename = "contactPointGeneration"))]
167    #[cfg_attr(feature = "serde", serde(rename = "contactPointGeneration"))]
168    pub m_contactPointGeneration: ContactPointGeneration,
169    /// # C++ Info
170    /// - name: `allowToSkipConfirmedCallbacks`(ctype: `hkBool`)
171    /// - offset: `117`(x86)/`133`(x86_64)
172    /// - type_size: `  1`(x86)/`  1`(x86_64)
173    #[cfg_attr(
174        feature = "json_schema",
175        schemars(rename = "allowToSkipConfirmedCallbacks")
176    )]
177    #[cfg_attr(feature = "serde", serde(rename = "allowToSkipConfirmedCallbacks"))]
178    pub m_allowToSkipConfirmedCallbacks: bool,
179    /// # C++ Info
180    /// - name: `useHybridBroadphase`(ctype: `hkBool`)
181    /// - offset: `118`(x86)/`134`(x86_64)
182    /// - type_size: `  1`(x86)/`  1`(x86_64)
183    #[cfg_attr(feature = "json_schema", schemars(rename = "useHybridBroadphase"))]
184    #[cfg_attr(feature = "serde", serde(rename = "useHybridBroadphase"))]
185    pub m_useHybridBroadphase: bool,
186    /// # C++ Info
187    /// - name: `solverTau`(ctype: `hkReal`)
188    /// - offset: `120`(x86)/`136`(x86_64)
189    /// - type_size: `  4`(x86)/`  4`(x86_64)
190    #[cfg_attr(feature = "json_schema", schemars(rename = "solverTau"))]
191    #[cfg_attr(feature = "serde", serde(rename = "solverTau"))]
192    pub m_solverTau: f32,
193    /// # C++ Info
194    /// - name: `solverDamp`(ctype: `hkReal`)
195    /// - offset: `124`(x86)/`140`(x86_64)
196    /// - type_size: `  4`(x86)/`  4`(x86_64)
197    #[cfg_attr(feature = "json_schema", schemars(rename = "solverDamp"))]
198    #[cfg_attr(feature = "serde", serde(rename = "solverDamp"))]
199    pub m_solverDamp: f32,
200    /// # C++ Info
201    /// - name: `solverIterations`(ctype: `hkInt32`)
202    /// - offset: `128`(x86)/`144`(x86_64)
203    /// - type_size: `  4`(x86)/`  4`(x86_64)
204    #[cfg_attr(feature = "json_schema", schemars(rename = "solverIterations"))]
205    #[cfg_attr(feature = "serde", serde(rename = "solverIterations"))]
206    pub m_solverIterations: i32,
207    /// # C++ Info
208    /// - name: `solverMicrosteps`(ctype: `hkInt32`)
209    /// - offset: `132`(x86)/`148`(x86_64)
210    /// - type_size: `  4`(x86)/`  4`(x86_64)
211    #[cfg_attr(feature = "json_schema", schemars(rename = "solverMicrosteps"))]
212    #[cfg_attr(feature = "serde", serde(rename = "solverMicrosteps"))]
213    pub m_solverMicrosteps: i32,
214    /// # C++ Info
215    /// - name: `maxConstraintViolation`(ctype: `hkReal`)
216    /// - offset: `136`(x86)/`152`(x86_64)
217    /// - type_size: `  4`(x86)/`  4`(x86_64)
218    #[cfg_attr(feature = "json_schema", schemars(rename = "maxConstraintViolation"))]
219    #[cfg_attr(feature = "serde", serde(rename = "maxConstraintViolation"))]
220    pub m_maxConstraintViolation: f32,
221    /// # C++ Info
222    /// - name: `forceCoherentConstraintOrderingInSolver`(ctype: `hkBool`)
223    /// - offset: `140`(x86)/`156`(x86_64)
224    /// - type_size: `  1`(x86)/`  1`(x86_64)
225    #[cfg_attr(
226        feature = "json_schema",
227        schemars(rename = "forceCoherentConstraintOrderingInSolver")
228    )]
229    #[cfg_attr(
230        feature = "serde",
231        serde(rename = "forceCoherentConstraintOrderingInSolver")
232    )]
233    pub m_forceCoherentConstraintOrderingInSolver: bool,
234    /// # C++ Info
235    /// - name: `snapCollisionToConvexEdgeThreshold`(ctype: `hkReal`)
236    /// - offset: `144`(x86)/`160`(x86_64)
237    /// - type_size: `  4`(x86)/`  4`(x86_64)
238    #[cfg_attr(
239        feature = "json_schema",
240        schemars(rename = "snapCollisionToConvexEdgeThreshold")
241    )]
242    #[cfg_attr(feature = "serde", serde(rename = "snapCollisionToConvexEdgeThreshold"))]
243    pub m_snapCollisionToConvexEdgeThreshold: f32,
244    /// # C++ Info
245    /// - name: `snapCollisionToConcaveEdgeThreshold`(ctype: `hkReal`)
246    /// - offset: `148`(x86)/`164`(x86_64)
247    /// - type_size: `  4`(x86)/`  4`(x86_64)
248    #[cfg_attr(
249        feature = "json_schema",
250        schemars(rename = "snapCollisionToConcaveEdgeThreshold")
251    )]
252    #[cfg_attr(feature = "serde", serde(rename = "snapCollisionToConcaveEdgeThreshold"))]
253    pub m_snapCollisionToConcaveEdgeThreshold: f32,
254    /// # C++ Info
255    /// - name: `enableToiWeldRejection`(ctype: `hkBool`)
256    /// - offset: `152`(x86)/`168`(x86_64)
257    /// - type_size: `  1`(x86)/`  1`(x86_64)
258    #[cfg_attr(feature = "json_schema", schemars(rename = "enableToiWeldRejection"))]
259    #[cfg_attr(feature = "serde", serde(rename = "enableToiWeldRejection"))]
260    pub m_enableToiWeldRejection: bool,
261    /// # C++ Info
262    /// - name: `enableDeprecatedWelding`(ctype: `hkBool`)
263    /// - offset: `153`(x86)/`169`(x86_64)
264    /// - type_size: `  1`(x86)/`  1`(x86_64)
265    #[cfg_attr(feature = "json_schema", schemars(rename = "enableDeprecatedWelding"))]
266    #[cfg_attr(feature = "serde", serde(rename = "enableDeprecatedWelding"))]
267    pub m_enableDeprecatedWelding: bool,
268    /// # C++ Info
269    /// - name: `iterativeLinearCastEarlyOutDistance`(ctype: `hkReal`)
270    /// - offset: `156`(x86)/`172`(x86_64)
271    /// - type_size: `  4`(x86)/`  4`(x86_64)
272    #[cfg_attr(
273        feature = "json_schema",
274        schemars(rename = "iterativeLinearCastEarlyOutDistance")
275    )]
276    #[cfg_attr(feature = "serde", serde(rename = "iterativeLinearCastEarlyOutDistance"))]
277    pub m_iterativeLinearCastEarlyOutDistance: f32,
278    /// # C++ Info
279    /// - name: `iterativeLinearCastMaxIterations`(ctype: `hkInt32`)
280    /// - offset: `160`(x86)/`176`(x86_64)
281    /// - type_size: `  4`(x86)/`  4`(x86_64)
282    #[cfg_attr(
283        feature = "json_schema",
284        schemars(rename = "iterativeLinearCastMaxIterations")
285    )]
286    #[cfg_attr(feature = "serde", serde(rename = "iterativeLinearCastMaxIterations"))]
287    pub m_iterativeLinearCastMaxIterations: i32,
288    /// # C++ Info
289    /// - name: `deactivationNumInactiveFramesSelectFlag0`(ctype: `hkUint8`)
290    /// - offset: `164`(x86)/`180`(x86_64)
291    /// - type_size: `  1`(x86)/`  1`(x86_64)
292    #[cfg_attr(
293        feature = "json_schema",
294        schemars(rename = "deactivationNumInactiveFramesSelectFlag0")
295    )]
296    #[cfg_attr(
297        feature = "serde",
298        serde(rename = "deactivationNumInactiveFramesSelectFlag0")
299    )]
300    pub m_deactivationNumInactiveFramesSelectFlag0: u8,
301    /// # C++ Info
302    /// - name: `deactivationNumInactiveFramesSelectFlag1`(ctype: `hkUint8`)
303    /// - offset: `165`(x86)/`181`(x86_64)
304    /// - type_size: `  1`(x86)/`  1`(x86_64)
305    #[cfg_attr(
306        feature = "json_schema",
307        schemars(rename = "deactivationNumInactiveFramesSelectFlag1")
308    )]
309    #[cfg_attr(
310        feature = "serde",
311        serde(rename = "deactivationNumInactiveFramesSelectFlag1")
312    )]
313    pub m_deactivationNumInactiveFramesSelectFlag1: u8,
314    /// # C++ Info
315    /// - name: `deactivationIntegrateCounter`(ctype: `hkUint8`)
316    /// - offset: `166`(x86)/`182`(x86_64)
317    /// - type_size: `  1`(x86)/`  1`(x86_64)
318    #[cfg_attr(
319        feature = "json_schema",
320        schemars(rename = "deactivationIntegrateCounter")
321    )]
322    #[cfg_attr(feature = "serde", serde(rename = "deactivationIntegrateCounter"))]
323    pub m_deactivationIntegrateCounter: u8,
324    /// # C++ Info
325    /// - name: `shouldActivateOnRigidBodyTransformChange`(ctype: `hkBool`)
326    /// - offset: `167`(x86)/`183`(x86_64)
327    /// - type_size: `  1`(x86)/`  1`(x86_64)
328    #[cfg_attr(
329        feature = "json_schema",
330        schemars(rename = "shouldActivateOnRigidBodyTransformChange")
331    )]
332    #[cfg_attr(
333        feature = "serde",
334        serde(rename = "shouldActivateOnRigidBodyTransformChange")
335    )]
336    pub m_shouldActivateOnRigidBodyTransformChange: bool,
337    /// # C++ Info
338    /// - name: `deactivationReferenceDistance`(ctype: `hkReal`)
339    /// - offset: `168`(x86)/`184`(x86_64)
340    /// - type_size: `  4`(x86)/`  4`(x86_64)
341    #[cfg_attr(
342        feature = "json_schema",
343        schemars(rename = "deactivationReferenceDistance")
344    )]
345    #[cfg_attr(feature = "serde", serde(rename = "deactivationReferenceDistance"))]
346    pub m_deactivationReferenceDistance: f32,
347    /// # C++ Info
348    /// - name: `toiCollisionResponseRotateNormal`(ctype: `hkReal`)
349    /// - offset: `172`(x86)/`188`(x86_64)
350    /// - type_size: `  4`(x86)/`  4`(x86_64)
351    #[cfg_attr(
352        feature = "json_schema",
353        schemars(rename = "toiCollisionResponseRotateNormal")
354    )]
355    #[cfg_attr(feature = "serde", serde(rename = "toiCollisionResponseRotateNormal"))]
356    pub m_toiCollisionResponseRotateNormal: f32,
357    /// # C++ Info
358    /// - name: `maxSectorsPerMidphaseCollideTask`(ctype: `hkInt32`)
359    /// - offset: `176`(x86)/`192`(x86_64)
360    /// - type_size: `  4`(x86)/`  4`(x86_64)
361    #[cfg_attr(
362        feature = "json_schema",
363        schemars(rename = "maxSectorsPerMidphaseCollideTask")
364    )]
365    #[cfg_attr(feature = "serde", serde(rename = "maxSectorsPerMidphaseCollideTask"))]
366    pub m_maxSectorsPerMidphaseCollideTask: i32,
367    /// # C++ Info
368    /// - name: `maxSectorsPerNarrowphaseCollideTask`(ctype: `hkInt32`)
369    /// - offset: `180`(x86)/`196`(x86_64)
370    /// - type_size: `  4`(x86)/`  4`(x86_64)
371    #[cfg_attr(
372        feature = "json_schema",
373        schemars(rename = "maxSectorsPerNarrowphaseCollideTask")
374    )]
375    #[cfg_attr(feature = "serde", serde(rename = "maxSectorsPerNarrowphaseCollideTask"))]
376    pub m_maxSectorsPerNarrowphaseCollideTask: i32,
377    /// # C++ Info
378    /// - name: `processToisMultithreaded`(ctype: `hkBool`)
379    /// - offset: `184`(x86)/`200`(x86_64)
380    /// - type_size: `  1`(x86)/`  1`(x86_64)
381    #[cfg_attr(feature = "json_schema", schemars(rename = "processToisMultithreaded"))]
382    #[cfg_attr(feature = "serde", serde(rename = "processToisMultithreaded"))]
383    pub m_processToisMultithreaded: bool,
384    /// # C++ Info
385    /// - name: `maxEntriesPerToiMidphaseCollideTask`(ctype: `hkInt32`)
386    /// - offset: `188`(x86)/`204`(x86_64)
387    /// - type_size: `  4`(x86)/`  4`(x86_64)
388    #[cfg_attr(
389        feature = "json_schema",
390        schemars(rename = "maxEntriesPerToiMidphaseCollideTask")
391    )]
392    #[cfg_attr(feature = "serde", serde(rename = "maxEntriesPerToiMidphaseCollideTask"))]
393    pub m_maxEntriesPerToiMidphaseCollideTask: i32,
394    /// # C++ Info
395    /// - name: `maxEntriesPerToiNarrowphaseCollideTask`(ctype: `hkInt32`)
396    /// - offset: `192`(x86)/`208`(x86_64)
397    /// - type_size: `  4`(x86)/`  4`(x86_64)
398    #[cfg_attr(
399        feature = "json_schema",
400        schemars(rename = "maxEntriesPerToiNarrowphaseCollideTask")
401    )]
402    #[cfg_attr(
403        feature = "serde",
404        serde(rename = "maxEntriesPerToiNarrowphaseCollideTask")
405    )]
406    pub m_maxEntriesPerToiNarrowphaseCollideTask: i32,
407    /// # C++ Info
408    /// - name: `maxNumToiCollisionPairsSinglethreaded`(ctype: `hkInt32`)
409    /// - offset: `196`(x86)/`212`(x86_64)
410    /// - type_size: `  4`(x86)/`  4`(x86_64)
411    #[cfg_attr(
412        feature = "json_schema",
413        schemars(rename = "maxNumToiCollisionPairsSinglethreaded")
414    )]
415    #[cfg_attr(
416        feature = "serde",
417        serde(rename = "maxNumToiCollisionPairsSinglethreaded")
418    )]
419    pub m_maxNumToiCollisionPairsSinglethreaded: i32,
420    /// # C++ Info
421    /// - name: `numToisTillAllowedPenetrationSimplifiedToi`(ctype: `hkReal`)
422    /// - offset: `200`(x86)/`216`(x86_64)
423    /// - type_size: `  4`(x86)/`  4`(x86_64)
424    #[cfg_attr(
425        feature = "json_schema",
426        schemars(rename = "numToisTillAllowedPenetrationSimplifiedToi")
427    )]
428    #[cfg_attr(
429        feature = "serde",
430        serde(rename = "numToisTillAllowedPenetrationSimplifiedToi")
431    )]
432    pub m_numToisTillAllowedPenetrationSimplifiedToi: f32,
433    /// # C++ Info
434    /// - name: `numToisTillAllowedPenetrationToi`(ctype: `hkReal`)
435    /// - offset: `204`(x86)/`220`(x86_64)
436    /// - type_size: `  4`(x86)/`  4`(x86_64)
437    #[cfg_attr(
438        feature = "json_schema",
439        schemars(rename = "numToisTillAllowedPenetrationToi")
440    )]
441    #[cfg_attr(feature = "serde", serde(rename = "numToisTillAllowedPenetrationToi"))]
442    pub m_numToisTillAllowedPenetrationToi: f32,
443    /// # C++ Info
444    /// - name: `numToisTillAllowedPenetrationToiHigher`(ctype: `hkReal`)
445    /// - offset: `208`(x86)/`224`(x86_64)
446    /// - type_size: `  4`(x86)/`  4`(x86_64)
447    #[cfg_attr(
448        feature = "json_schema",
449        schemars(rename = "numToisTillAllowedPenetrationToiHigher")
450    )]
451    #[cfg_attr(
452        feature = "serde",
453        serde(rename = "numToisTillAllowedPenetrationToiHigher")
454    )]
455    pub m_numToisTillAllowedPenetrationToiHigher: f32,
456    /// # C++ Info
457    /// - name: `numToisTillAllowedPenetrationToiForced`(ctype: `hkReal`)
458    /// - offset: `212`(x86)/`228`(x86_64)
459    /// - type_size: `  4`(x86)/`  4`(x86_64)
460    #[cfg_attr(
461        feature = "json_schema",
462        schemars(rename = "numToisTillAllowedPenetrationToiForced")
463    )]
464    #[cfg_attr(
465        feature = "serde",
466        serde(rename = "numToisTillAllowedPenetrationToiForced")
467    )]
468    pub m_numToisTillAllowedPenetrationToiForced: f32,
469    /// # C++ Info
470    /// - name: `enableDeactivation`(ctype: `hkBool`)
471    /// - offset: `216`(x86)/`232`(x86_64)
472    /// - type_size: `  1`(x86)/`  1`(x86_64)
473    #[cfg_attr(feature = "json_schema", schemars(rename = "enableDeactivation"))]
474    #[cfg_attr(feature = "serde", serde(rename = "enableDeactivation"))]
475    pub m_enableDeactivation: bool,
476    /// # C++ Info
477    /// - name: `simulationType`(ctype: `enum SimulationType`)
478    /// - offset: `217`(x86)/`233`(x86_64)
479    /// - type_size: `  1`(x86)/`  1`(x86_64)
480    #[cfg_attr(feature = "json_schema", schemars(rename = "simulationType"))]
481    #[cfg_attr(feature = "serde", serde(rename = "simulationType"))]
482    pub m_simulationType: SimulationType,
483    /// # C++ Info
484    /// - name: `enableSimulationIslands`(ctype: `hkBool`)
485    /// - offset: `218`(x86)/`234`(x86_64)
486    /// - type_size: `  1`(x86)/`  1`(x86_64)
487    #[cfg_attr(feature = "json_schema", schemars(rename = "enableSimulationIslands"))]
488    #[cfg_attr(feature = "serde", serde(rename = "enableSimulationIslands"))]
489    pub m_enableSimulationIslands: bool,
490    /// # C++ Info
491    /// - name: `minDesiredIslandSize`(ctype: `hkUint32`)
492    /// - offset: `220`(x86)/`236`(x86_64)
493    /// - type_size: `  4`(x86)/`  4`(x86_64)
494    #[cfg_attr(feature = "json_schema", schemars(rename = "minDesiredIslandSize"))]
495    #[cfg_attr(feature = "serde", serde(rename = "minDesiredIslandSize"))]
496    pub m_minDesiredIslandSize: u32,
497    /// # C++ Info
498    /// - name: `processActionsInSingleThread`(ctype: `hkBool`)
499    /// - offset: `224`(x86)/`240`(x86_64)
500    /// - type_size: `  1`(x86)/`  1`(x86_64)
501    #[cfg_attr(
502        feature = "json_schema",
503        schemars(rename = "processActionsInSingleThread")
504    )]
505    #[cfg_attr(feature = "serde", serde(rename = "processActionsInSingleThread"))]
506    pub m_processActionsInSingleThread: bool,
507    /// # C++ Info
508    /// - name: `allowIntegrationOfIslandsWithoutConstraintsInASeparateJob`(ctype: `hkBool`)
509    /// - offset: `225`(x86)/`241`(x86_64)
510    /// - type_size: `  1`(x86)/`  1`(x86_64)
511    #[cfg_attr(
512        feature = "json_schema",
513        schemars(rename = "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob")
514    )]
515    #[cfg_attr(
516        feature = "serde",
517        serde(rename = "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob")
518    )]
519    pub m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob: bool,
520    /// # C++ Info
521    /// - name: `frameMarkerPsiSnap`(ctype: `hkReal`)
522    /// - offset: `228`(x86)/`244`(x86_64)
523    /// - type_size: `  4`(x86)/`  4`(x86_64)
524    #[cfg_attr(feature = "json_schema", schemars(rename = "frameMarkerPsiSnap"))]
525    #[cfg_attr(feature = "serde", serde(rename = "frameMarkerPsiSnap"))]
526    pub m_frameMarkerPsiSnap: f32,
527    /// # C++ Info
528    /// - name: `fireCollisionCallbacks`(ctype: `hkBool`)
529    /// - offset: `232`(x86)/`248`(x86_64)
530    /// - type_size: `  1`(x86)/`  1`(x86_64)
531    #[cfg_attr(feature = "json_schema", schemars(rename = "fireCollisionCallbacks"))]
532    #[cfg_attr(feature = "serde", serde(rename = "fireCollisionCallbacks"))]
533    pub m_fireCollisionCallbacks: bool,
534}
535const _: () = {
536    use havok_serde as _serde;
537    impl _serde::HavokClass for hkpWorldCinfo {
538        #[inline]
539        fn name(&self) -> &'static str {
540            "hkpWorldCinfo"
541        }
542        #[inline]
543        fn signature(&self) -> _serde::__private::Signature {
544            _serde::__private::Signature::new(0xa5255445)
545        }
546        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
547        fn deps_indexes(&self) -> Vec<usize> {
548            let mut v = Vec::new();
549            v.extend(self.m_broadPhaseWorldAabb.deps_indexes());
550            v.push(self.m_collisionFilter.get());
551            v.push(self.m_convexListFilter.get());
552            v.push(self.m_memoryWatchDog.get());
553            v
554        }
555    }
556    impl _serde::Serialize for hkpWorldCinfo {
557        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
558        where
559            S: _serde::ser::Serializer,
560        {
561            let class_meta = self
562                .__ptr
563                .map(|name| (name, _serde::__private::Signature::new(0xa5255445)));
564            let mut serializer = __serializer
565                .serialize_struct("hkpWorldCinfo", class_meta, (240u64, 256u64))?;
566            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
567            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
568            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
569            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
570            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
571            serializer.serialize_field("gravity", &self.m_gravity)?;
572            serializer
573                .serialize_field("broadPhaseQuerySize", &self.m_broadPhaseQuerySize)?;
574            serializer
575                .serialize_field(
576                    "contactRestingVelocity",
577                    &self.m_contactRestingVelocity,
578                )?;
579            serializer
580                .serialize_field(
581                    "broadPhaseBorderBehaviour",
582                    &self.m_broadPhaseBorderBehaviour,
583                )?;
584            serializer
585                .serialize_field(
586                    "mtPostponeAndSortBroadPhaseBorderCallbacks",
587                    &self.m_mtPostponeAndSortBroadPhaseBorderCallbacks,
588                )?;
589            serializer.pad_field([0u8; 6usize].as_slice(), [0u8; 6usize].as_slice())?;
590            serializer
591                .serialize_field("broadPhaseWorldAabb", &self.m_broadPhaseWorldAabb)?;
592            serializer.serialize_field("useKdTree", &self.m_useKdTree)?;
593            serializer.serialize_field("useMultipleTree", &self.m_useMultipleTree)?;
594            serializer.serialize_field("treeUpdateType", &self.m_treeUpdateType)?;
595            serializer.serialize_field("autoUpdateKdTree", &self.m_autoUpdateKdTree)?;
596            serializer
597                .serialize_field("collisionTolerance", &self.m_collisionTolerance)?;
598            serializer.serialize_field("collisionFilter", &self.m_collisionFilter)?;
599            serializer.serialize_field("convexListFilter", &self.m_convexListFilter)?;
600            serializer
601                .serialize_field(
602                    "expectedMaxLinearVelocity",
603                    &self.m_expectedMaxLinearVelocity,
604                )?;
605            serializer
606                .serialize_field("sizeOfToiEventQueue", &self.m_sizeOfToiEventQueue)?;
607            serializer
608                .serialize_field(
609                    "expectedMinPsiDeltaTime",
610                    &self.m_expectedMinPsiDeltaTime,
611                )?;
612            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
613            serializer.serialize_field("memoryWatchDog", &self.m_memoryWatchDog)?;
614            serializer
615                .serialize_field("broadPhaseNumMarkers", &self.m_broadPhaseNumMarkers)?;
616            serializer
617                .serialize_field(
618                    "contactPointGeneration",
619                    &self.m_contactPointGeneration,
620                )?;
621            serializer
622                .serialize_field(
623                    "allowToSkipConfirmedCallbacks",
624                    &self.m_allowToSkipConfirmedCallbacks,
625                )?;
626            serializer
627                .serialize_field("useHybridBroadphase", &self.m_useHybridBroadphase)?;
628            serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
629            serializer.serialize_field("solverTau", &self.m_solverTau)?;
630            serializer.serialize_field("solverDamp", &self.m_solverDamp)?;
631            serializer.serialize_field("solverIterations", &self.m_solverIterations)?;
632            serializer.serialize_field("solverMicrosteps", &self.m_solverMicrosteps)?;
633            serializer
634                .serialize_field(
635                    "maxConstraintViolation",
636                    &self.m_maxConstraintViolation,
637                )?;
638            serializer
639                .serialize_field(
640                    "forceCoherentConstraintOrderingInSolver",
641                    &self.m_forceCoherentConstraintOrderingInSolver,
642                )?;
643            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
644            serializer
645                .serialize_field(
646                    "snapCollisionToConvexEdgeThreshold",
647                    &self.m_snapCollisionToConvexEdgeThreshold,
648                )?;
649            serializer
650                .serialize_field(
651                    "snapCollisionToConcaveEdgeThreshold",
652                    &self.m_snapCollisionToConcaveEdgeThreshold,
653                )?;
654            serializer
655                .serialize_field(
656                    "enableToiWeldRejection",
657                    &self.m_enableToiWeldRejection,
658                )?;
659            serializer
660                .serialize_field(
661                    "enableDeprecatedWelding",
662                    &self.m_enableDeprecatedWelding,
663                )?;
664            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
665            serializer
666                .serialize_field(
667                    "iterativeLinearCastEarlyOutDistance",
668                    &self.m_iterativeLinearCastEarlyOutDistance,
669                )?;
670            serializer
671                .serialize_field(
672                    "iterativeLinearCastMaxIterations",
673                    &self.m_iterativeLinearCastMaxIterations,
674                )?;
675            serializer
676                .serialize_field(
677                    "deactivationNumInactiveFramesSelectFlag0",
678                    &self.m_deactivationNumInactiveFramesSelectFlag0,
679                )?;
680            serializer
681                .serialize_field(
682                    "deactivationNumInactiveFramesSelectFlag1",
683                    &self.m_deactivationNumInactiveFramesSelectFlag1,
684                )?;
685            serializer
686                .serialize_field(
687                    "deactivationIntegrateCounter",
688                    &self.m_deactivationIntegrateCounter,
689                )?;
690            serializer
691                .serialize_field(
692                    "shouldActivateOnRigidBodyTransformChange",
693                    &self.m_shouldActivateOnRigidBodyTransformChange,
694                )?;
695            serializer
696                .serialize_field(
697                    "deactivationReferenceDistance",
698                    &self.m_deactivationReferenceDistance,
699                )?;
700            serializer
701                .serialize_field(
702                    "toiCollisionResponseRotateNormal",
703                    &self.m_toiCollisionResponseRotateNormal,
704                )?;
705            serializer
706                .serialize_field(
707                    "maxSectorsPerMidphaseCollideTask",
708                    &self.m_maxSectorsPerMidphaseCollideTask,
709                )?;
710            serializer
711                .serialize_field(
712                    "maxSectorsPerNarrowphaseCollideTask",
713                    &self.m_maxSectorsPerNarrowphaseCollideTask,
714                )?;
715            serializer
716                .serialize_field(
717                    "processToisMultithreaded",
718                    &self.m_processToisMultithreaded,
719                )?;
720            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
721            serializer
722                .serialize_field(
723                    "maxEntriesPerToiMidphaseCollideTask",
724                    &self.m_maxEntriesPerToiMidphaseCollideTask,
725                )?;
726            serializer
727                .serialize_field(
728                    "maxEntriesPerToiNarrowphaseCollideTask",
729                    &self.m_maxEntriesPerToiNarrowphaseCollideTask,
730                )?;
731            serializer
732                .serialize_field(
733                    "maxNumToiCollisionPairsSinglethreaded",
734                    &self.m_maxNumToiCollisionPairsSinglethreaded,
735                )?;
736            serializer
737                .serialize_field(
738                    "numToisTillAllowedPenetrationSimplifiedToi",
739                    &self.m_numToisTillAllowedPenetrationSimplifiedToi,
740                )?;
741            serializer
742                .serialize_field(
743                    "numToisTillAllowedPenetrationToi",
744                    &self.m_numToisTillAllowedPenetrationToi,
745                )?;
746            serializer
747                .serialize_field(
748                    "numToisTillAllowedPenetrationToiHigher",
749                    &self.m_numToisTillAllowedPenetrationToiHigher,
750                )?;
751            serializer
752                .serialize_field(
753                    "numToisTillAllowedPenetrationToiForced",
754                    &self.m_numToisTillAllowedPenetrationToiForced,
755                )?;
756            serializer
757                .serialize_field("enableDeactivation", &self.m_enableDeactivation)?;
758            serializer.serialize_field("simulationType", &self.m_simulationType)?;
759            serializer
760                .serialize_field(
761                    "enableSimulationIslands",
762                    &self.m_enableSimulationIslands,
763                )?;
764            serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
765            serializer
766                .serialize_field("minDesiredIslandSize", &self.m_minDesiredIslandSize)?;
767            serializer
768                .serialize_field(
769                    "processActionsInSingleThread",
770                    &self.m_processActionsInSingleThread,
771                )?;
772            serializer
773                .serialize_field(
774                    "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob",
775                    &self.m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob,
776                )?;
777            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
778            serializer
779                .serialize_field("frameMarkerPsiSnap", &self.m_frameMarkerPsiSnap)?;
780            serializer
781                .serialize_field(
782                    "fireCollisionCallbacks",
783                    &self.m_fireCollisionCallbacks,
784                )?;
785            serializer.pad_field([0u8; 7usize].as_slice(), [0u8; 7usize].as_slice())?;
786            serializer.end()
787        }
788    }
789};
790#[doc(hidden)]
791#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
792const _: () = {
793    use havok_serde as _serde;
794    #[automatically_derived]
795    impl<'de> _serde::Deserialize<'de> for hkpWorldCinfo {
796        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
797        where
798            __D: _serde::Deserializer<'de>,
799        {
800            #[allow(non_camel_case_types)]
801            enum __Field {
802                m_gravity,
803                m_broadPhaseQuerySize,
804                m_contactRestingVelocity,
805                m_broadPhaseBorderBehaviour,
806                m_mtPostponeAndSortBroadPhaseBorderCallbacks,
807                m_broadPhaseWorldAabb,
808                m_useKdTree,
809                m_useMultipleTree,
810                m_treeUpdateType,
811                m_autoUpdateKdTree,
812                m_collisionTolerance,
813                m_collisionFilter,
814                m_convexListFilter,
815                m_expectedMaxLinearVelocity,
816                m_sizeOfToiEventQueue,
817                m_expectedMinPsiDeltaTime,
818                m_memoryWatchDog,
819                m_broadPhaseNumMarkers,
820                m_contactPointGeneration,
821                m_allowToSkipConfirmedCallbacks,
822                m_useHybridBroadphase,
823                m_solverTau,
824                m_solverDamp,
825                m_solverIterations,
826                m_solverMicrosteps,
827                m_maxConstraintViolation,
828                m_forceCoherentConstraintOrderingInSolver,
829                m_snapCollisionToConvexEdgeThreshold,
830                m_snapCollisionToConcaveEdgeThreshold,
831                m_enableToiWeldRejection,
832                m_enableDeprecatedWelding,
833                m_iterativeLinearCastEarlyOutDistance,
834                m_iterativeLinearCastMaxIterations,
835                m_deactivationNumInactiveFramesSelectFlag0,
836                m_deactivationNumInactiveFramesSelectFlag1,
837                m_deactivationIntegrateCounter,
838                m_shouldActivateOnRigidBodyTransformChange,
839                m_deactivationReferenceDistance,
840                m_toiCollisionResponseRotateNormal,
841                m_maxSectorsPerMidphaseCollideTask,
842                m_maxSectorsPerNarrowphaseCollideTask,
843                m_processToisMultithreaded,
844                m_maxEntriesPerToiMidphaseCollideTask,
845                m_maxEntriesPerToiNarrowphaseCollideTask,
846                m_maxNumToiCollisionPairsSinglethreaded,
847                m_numToisTillAllowedPenetrationSimplifiedToi,
848                m_numToisTillAllowedPenetrationToi,
849                m_numToisTillAllowedPenetrationToiHigher,
850                m_numToisTillAllowedPenetrationToiForced,
851                m_enableDeactivation,
852                m_simulationType,
853                m_enableSimulationIslands,
854                m_minDesiredIslandSize,
855                m_processActionsInSingleThread,
856                m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob,
857                m_frameMarkerPsiSnap,
858                m_fireCollisionCallbacks,
859                __ignore,
860            }
861            struct __FieldVisitor;
862            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
863                type Value = __Field;
864                fn expecting(
865                    &self,
866                    __formatter: &mut core::fmt::Formatter,
867                ) -> core::fmt::Result {
868                    core::fmt::Formatter::write_str(__formatter, "field identifier")
869                }
870                /// Intended for use in XML.
871                #[allow(clippy::match_single_binding)]
872                #[allow(clippy::reversed_empty_ranges)]
873                #[allow(clippy::single_match)]
874                fn visit_key<__E>(
875                    self,
876                    __value: &str,
877                ) -> core::result::Result<Self::Value, __E>
878                where
879                    __E: _serde::de::Error,
880                {
881                    match __value {
882                        "gravity" => Ok(__Field::m_gravity),
883                        "broadPhaseQuerySize" => Ok(__Field::m_broadPhaseQuerySize),
884                        "contactRestingVelocity" => Ok(__Field::m_contactRestingVelocity),
885                        "broadPhaseBorderBehaviour" => {
886                            Ok(__Field::m_broadPhaseBorderBehaviour)
887                        }
888                        "mtPostponeAndSortBroadPhaseBorderCallbacks" => {
889                            Ok(__Field::m_mtPostponeAndSortBroadPhaseBorderCallbacks)
890                        }
891                        "broadPhaseWorldAabb" => Ok(__Field::m_broadPhaseWorldAabb),
892                        "useKdTree" => Ok(__Field::m_useKdTree),
893                        "useMultipleTree" => Ok(__Field::m_useMultipleTree),
894                        "treeUpdateType" => Ok(__Field::m_treeUpdateType),
895                        "autoUpdateKdTree" => Ok(__Field::m_autoUpdateKdTree),
896                        "collisionTolerance" => Ok(__Field::m_collisionTolerance),
897                        "collisionFilter" => Ok(__Field::m_collisionFilter),
898                        "convexListFilter" => Ok(__Field::m_convexListFilter),
899                        "expectedMaxLinearVelocity" => {
900                            Ok(__Field::m_expectedMaxLinearVelocity)
901                        }
902                        "sizeOfToiEventQueue" => Ok(__Field::m_sizeOfToiEventQueue),
903                        "expectedMinPsiDeltaTime" => {
904                            Ok(__Field::m_expectedMinPsiDeltaTime)
905                        }
906                        "memoryWatchDog" => Ok(__Field::m_memoryWatchDog),
907                        "broadPhaseNumMarkers" => Ok(__Field::m_broadPhaseNumMarkers),
908                        "contactPointGeneration" => Ok(__Field::m_contactPointGeneration),
909                        "allowToSkipConfirmedCallbacks" => {
910                            Ok(__Field::m_allowToSkipConfirmedCallbacks)
911                        }
912                        "useHybridBroadphase" => Ok(__Field::m_useHybridBroadphase),
913                        "solverTau" => Ok(__Field::m_solverTau),
914                        "solverDamp" => Ok(__Field::m_solverDamp),
915                        "solverIterations" => Ok(__Field::m_solverIterations),
916                        "solverMicrosteps" => Ok(__Field::m_solverMicrosteps),
917                        "maxConstraintViolation" => Ok(__Field::m_maxConstraintViolation),
918                        "forceCoherentConstraintOrderingInSolver" => {
919                            Ok(__Field::m_forceCoherentConstraintOrderingInSolver)
920                        }
921                        "snapCollisionToConvexEdgeThreshold" => {
922                            Ok(__Field::m_snapCollisionToConvexEdgeThreshold)
923                        }
924                        "snapCollisionToConcaveEdgeThreshold" => {
925                            Ok(__Field::m_snapCollisionToConcaveEdgeThreshold)
926                        }
927                        "enableToiWeldRejection" => Ok(__Field::m_enableToiWeldRejection),
928                        "enableDeprecatedWelding" => {
929                            Ok(__Field::m_enableDeprecatedWelding)
930                        }
931                        "iterativeLinearCastEarlyOutDistance" => {
932                            Ok(__Field::m_iterativeLinearCastEarlyOutDistance)
933                        }
934                        "iterativeLinearCastMaxIterations" => {
935                            Ok(__Field::m_iterativeLinearCastMaxIterations)
936                        }
937                        "deactivationNumInactiveFramesSelectFlag0" => {
938                            Ok(__Field::m_deactivationNumInactiveFramesSelectFlag0)
939                        }
940                        "deactivationNumInactiveFramesSelectFlag1" => {
941                            Ok(__Field::m_deactivationNumInactiveFramesSelectFlag1)
942                        }
943                        "deactivationIntegrateCounter" => {
944                            Ok(__Field::m_deactivationIntegrateCounter)
945                        }
946                        "shouldActivateOnRigidBodyTransformChange" => {
947                            Ok(__Field::m_shouldActivateOnRigidBodyTransformChange)
948                        }
949                        "deactivationReferenceDistance" => {
950                            Ok(__Field::m_deactivationReferenceDistance)
951                        }
952                        "toiCollisionResponseRotateNormal" => {
953                            Ok(__Field::m_toiCollisionResponseRotateNormal)
954                        }
955                        "maxSectorsPerMidphaseCollideTask" => {
956                            Ok(__Field::m_maxSectorsPerMidphaseCollideTask)
957                        }
958                        "maxSectorsPerNarrowphaseCollideTask" => {
959                            Ok(__Field::m_maxSectorsPerNarrowphaseCollideTask)
960                        }
961                        "processToisMultithreaded" => {
962                            Ok(__Field::m_processToisMultithreaded)
963                        }
964                        "maxEntriesPerToiMidphaseCollideTask" => {
965                            Ok(__Field::m_maxEntriesPerToiMidphaseCollideTask)
966                        }
967                        "maxEntriesPerToiNarrowphaseCollideTask" => {
968                            Ok(__Field::m_maxEntriesPerToiNarrowphaseCollideTask)
969                        }
970                        "maxNumToiCollisionPairsSinglethreaded" => {
971                            Ok(__Field::m_maxNumToiCollisionPairsSinglethreaded)
972                        }
973                        "numToisTillAllowedPenetrationSimplifiedToi" => {
974                            Ok(__Field::m_numToisTillAllowedPenetrationSimplifiedToi)
975                        }
976                        "numToisTillAllowedPenetrationToi" => {
977                            Ok(__Field::m_numToisTillAllowedPenetrationToi)
978                        }
979                        "numToisTillAllowedPenetrationToiHigher" => {
980                            Ok(__Field::m_numToisTillAllowedPenetrationToiHigher)
981                        }
982                        "numToisTillAllowedPenetrationToiForced" => {
983                            Ok(__Field::m_numToisTillAllowedPenetrationToiForced)
984                        }
985                        "enableDeactivation" => Ok(__Field::m_enableDeactivation),
986                        "simulationType" => Ok(__Field::m_simulationType),
987                        "enableSimulationIslands" => {
988                            Ok(__Field::m_enableSimulationIslands)
989                        }
990                        "minDesiredIslandSize" => Ok(__Field::m_minDesiredIslandSize),
991                        "processActionsInSingleThread" => {
992                            Ok(__Field::m_processActionsInSingleThread)
993                        }
994                        "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob" => {
995                            Ok(
996                                __Field::m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob,
997                            )
998                        }
999                        "frameMarkerPsiSnap" => Ok(__Field::m_frameMarkerPsiSnap),
1000                        "fireCollisionCallbacks" => Ok(__Field::m_fireCollisionCallbacks),
1001                        _ => Ok(__Field::__ignore),
1002                    }
1003                }
1004            }
1005            impl<'de> _serde::Deserialize<'de> for __Field {
1006                #[inline]
1007                fn deserialize<__D>(
1008                    __deserializer: __D,
1009                ) -> core::result::Result<Self, __D::Error>
1010                where
1011                    __D: _serde::Deserializer<'de>,
1012                {
1013                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
1014                }
1015            }
1016            struct __hkpWorldCinfoVisitor<'de> {
1017                marker: _serde::__private::PhantomData<hkpWorldCinfo>,
1018                lifetime: _serde::__private::PhantomData<&'de ()>,
1019            }
1020            #[allow(clippy::match_single_binding)]
1021            #[allow(clippy::reversed_empty_ranges)]
1022            #[allow(clippy::single_match)]
1023            impl<'de> _serde::de::Visitor<'de> for __hkpWorldCinfoVisitor<'de> {
1024                type Value = hkpWorldCinfo;
1025                fn expecting(
1026                    &self,
1027                    __formatter: &mut core::fmt::Formatter,
1028                ) -> core::fmt::Result {
1029                    core::fmt::Formatter::write_str(__formatter, "struct hkpWorldCinfo")
1030                }
1031                fn visit_struct_for_bytes<__A>(
1032                    self,
1033                    mut __map: __A,
1034                ) -> _serde::__private::Result<Self::Value, __A::Error>
1035                where
1036                    __A: _serde::de::MapAccess<'de>,
1037                {
1038                    let __ptr = __A::class_ptr(&mut __map);
1039                    let parent = __A::parent_value(&mut __map)?;
1040                    let mut m_gravity: _serde::__private::Option<Vector4> = _serde::__private::None;
1041                    let mut m_broadPhaseQuerySize: _serde::__private::Option<i32> = _serde::__private::None;
1042                    let mut m_contactRestingVelocity: _serde::__private::Option<f32> = _serde::__private::None;
1043                    let mut m_broadPhaseBorderBehaviour: _serde::__private::Option<
1044                        BroadPhaseBorderBehaviour,
1045                    > = _serde::__private::None;
1046                    let mut m_mtPostponeAndSortBroadPhaseBorderCallbacks: _serde::__private::Option<
1047                        bool,
1048                    > = _serde::__private::None;
1049                    let mut m_broadPhaseWorldAabb: _serde::__private::Option<hkAabb> = _serde::__private::None;
1050                    let mut m_useKdTree: _serde::__private::Option<bool> = _serde::__private::None;
1051                    let mut m_useMultipleTree: _serde::__private::Option<bool> = _serde::__private::None;
1052                    let mut m_treeUpdateType: _serde::__private::Option<
1053                        TreeUpdateType,
1054                    > = _serde::__private::None;
1055                    let mut m_autoUpdateKdTree: _serde::__private::Option<bool> = _serde::__private::None;
1056                    let mut m_collisionTolerance: _serde::__private::Option<f32> = _serde::__private::None;
1057                    let mut m_collisionFilter: _serde::__private::Option<Pointer> = _serde::__private::None;
1058                    let mut m_convexListFilter: _serde::__private::Option<Pointer> = _serde::__private::None;
1059                    let mut m_expectedMaxLinearVelocity: _serde::__private::Option<
1060                        f32,
1061                    > = _serde::__private::None;
1062                    let mut m_sizeOfToiEventQueue: _serde::__private::Option<i32> = _serde::__private::None;
1063                    let mut m_expectedMinPsiDeltaTime: _serde::__private::Option<f32> = _serde::__private::None;
1064                    let mut m_memoryWatchDog: _serde::__private::Option<Pointer> = _serde::__private::None;
1065                    let mut m_broadPhaseNumMarkers: _serde::__private::Option<i32> = _serde::__private::None;
1066                    let mut m_contactPointGeneration: _serde::__private::Option<
1067                        ContactPointGeneration,
1068                    > = _serde::__private::None;
1069                    let mut m_allowToSkipConfirmedCallbacks: _serde::__private::Option<
1070                        bool,
1071                    > = _serde::__private::None;
1072                    let mut m_useHybridBroadphase: _serde::__private::Option<bool> = _serde::__private::None;
1073                    let mut m_solverTau: _serde::__private::Option<f32> = _serde::__private::None;
1074                    let mut m_solverDamp: _serde::__private::Option<f32> = _serde::__private::None;
1075                    let mut m_solverIterations: _serde::__private::Option<i32> = _serde::__private::None;
1076                    let mut m_solverMicrosteps: _serde::__private::Option<i32> = _serde::__private::None;
1077                    let mut m_maxConstraintViolation: _serde::__private::Option<f32> = _serde::__private::None;
1078                    let mut m_forceCoherentConstraintOrderingInSolver: _serde::__private::Option<
1079                        bool,
1080                    > = _serde::__private::None;
1081                    let mut m_snapCollisionToConvexEdgeThreshold: _serde::__private::Option<
1082                        f32,
1083                    > = _serde::__private::None;
1084                    let mut m_snapCollisionToConcaveEdgeThreshold: _serde::__private::Option<
1085                        f32,
1086                    > = _serde::__private::None;
1087                    let mut m_enableToiWeldRejection: _serde::__private::Option<bool> = _serde::__private::None;
1088                    let mut m_enableDeprecatedWelding: _serde::__private::Option<bool> = _serde::__private::None;
1089                    let mut m_iterativeLinearCastEarlyOutDistance: _serde::__private::Option<
1090                        f32,
1091                    > = _serde::__private::None;
1092                    let mut m_iterativeLinearCastMaxIterations: _serde::__private::Option<
1093                        i32,
1094                    > = _serde::__private::None;
1095                    let mut m_deactivationNumInactiveFramesSelectFlag0: _serde::__private::Option<
1096                        u8,
1097                    > = _serde::__private::None;
1098                    let mut m_deactivationNumInactiveFramesSelectFlag1: _serde::__private::Option<
1099                        u8,
1100                    > = _serde::__private::None;
1101                    let mut m_deactivationIntegrateCounter: _serde::__private::Option<
1102                        u8,
1103                    > = _serde::__private::None;
1104                    let mut m_shouldActivateOnRigidBodyTransformChange: _serde::__private::Option<
1105                        bool,
1106                    > = _serde::__private::None;
1107                    let mut m_deactivationReferenceDistance: _serde::__private::Option<
1108                        f32,
1109                    > = _serde::__private::None;
1110                    let mut m_toiCollisionResponseRotateNormal: _serde::__private::Option<
1111                        f32,
1112                    > = _serde::__private::None;
1113                    let mut m_maxSectorsPerMidphaseCollideTask: _serde::__private::Option<
1114                        i32,
1115                    > = _serde::__private::None;
1116                    let mut m_maxSectorsPerNarrowphaseCollideTask: _serde::__private::Option<
1117                        i32,
1118                    > = _serde::__private::None;
1119                    let mut m_processToisMultithreaded: _serde::__private::Option<
1120                        bool,
1121                    > = _serde::__private::None;
1122                    let mut m_maxEntriesPerToiMidphaseCollideTask: _serde::__private::Option<
1123                        i32,
1124                    > = _serde::__private::None;
1125                    let mut m_maxEntriesPerToiNarrowphaseCollideTask: _serde::__private::Option<
1126                        i32,
1127                    > = _serde::__private::None;
1128                    let mut m_maxNumToiCollisionPairsSinglethreaded: _serde::__private::Option<
1129                        i32,
1130                    > = _serde::__private::None;
1131                    let mut m_numToisTillAllowedPenetrationSimplifiedToi: _serde::__private::Option<
1132                        f32,
1133                    > = _serde::__private::None;
1134                    let mut m_numToisTillAllowedPenetrationToi: _serde::__private::Option<
1135                        f32,
1136                    > = _serde::__private::None;
1137                    let mut m_numToisTillAllowedPenetrationToiHigher: _serde::__private::Option<
1138                        f32,
1139                    > = _serde::__private::None;
1140                    let mut m_numToisTillAllowedPenetrationToiForced: _serde::__private::Option<
1141                        f32,
1142                    > = _serde::__private::None;
1143                    let mut m_enableDeactivation: _serde::__private::Option<bool> = _serde::__private::None;
1144                    let mut m_simulationType: _serde::__private::Option<
1145                        SimulationType,
1146                    > = _serde::__private::None;
1147                    let mut m_enableSimulationIslands: _serde::__private::Option<bool> = _serde::__private::None;
1148                    let mut m_minDesiredIslandSize: _serde::__private::Option<u32> = _serde::__private::None;
1149                    let mut m_processActionsInSingleThread: _serde::__private::Option<
1150                        bool,
1151                    > = _serde::__private::None;
1152                    let mut m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob: _serde::__private::Option<
1153                        bool,
1154                    > = _serde::__private::None;
1155                    let mut m_frameMarkerPsiSnap: _serde::__private::Option<f32> = _serde::__private::None;
1156                    let mut m_fireCollisionCallbacks: _serde::__private::Option<bool> = _serde::__private::None;
1157                    for i in 0..57usize {
1158                        match i {
1159                            0usize => {
1160                                if _serde::__private::Option::is_some(&m_gravity) {
1161                                    return _serde::__private::Err(
1162                                        <__A::Error as _serde::de::Error>::duplicate_field(
1163                                            "gravity",
1164                                        ),
1165                                    );
1166                                }
1167                                __A::pad(&mut __map, 8usize, 0usize)?;
1168                                m_gravity = _serde::__private::Some(
1169                                    match __A::next_value::<Vector4>(&mut __map) {
1170                                        _serde::__private::Ok(__val) => __val,
1171                                        _serde::__private::Err(__err) => {
1172                                            return _serde::__private::Err(__err);
1173                                        }
1174                                    },
1175                                );
1176                            }
1177                            1usize => {
1178                                if _serde::__private::Option::is_some(
1179                                    &m_broadPhaseQuerySize,
1180                                ) {
1181                                    return _serde::__private::Err(
1182                                        <__A::Error as _serde::de::Error>::duplicate_field(
1183                                            "broadPhaseQuerySize",
1184                                        ),
1185                                    );
1186                                }
1187                                m_broadPhaseQuerySize = _serde::__private::Some(
1188                                    match __A::next_value::<i32>(&mut __map) {
1189                                        _serde::__private::Ok(__val) => __val,
1190                                        _serde::__private::Err(__err) => {
1191                                            return _serde::__private::Err(__err);
1192                                        }
1193                                    },
1194                                );
1195                            }
1196                            2usize => {
1197                                if _serde::__private::Option::is_some(
1198                                    &m_contactRestingVelocity,
1199                                ) {
1200                                    return _serde::__private::Err(
1201                                        <__A::Error as _serde::de::Error>::duplicate_field(
1202                                            "contactRestingVelocity",
1203                                        ),
1204                                    );
1205                                }
1206                                m_contactRestingVelocity = _serde::__private::Some(
1207                                    match __A::next_value::<f32>(&mut __map) {
1208                                        _serde::__private::Ok(__val) => __val,
1209                                        _serde::__private::Err(__err) => {
1210                                            return _serde::__private::Err(__err);
1211                                        }
1212                                    },
1213                                );
1214                            }
1215                            3usize => {
1216                                if _serde::__private::Option::is_some(
1217                                    &m_broadPhaseBorderBehaviour,
1218                                ) {
1219                                    return _serde::__private::Err(
1220                                        <__A::Error as _serde::de::Error>::duplicate_field(
1221                                            "broadPhaseBorderBehaviour",
1222                                        ),
1223                                    );
1224                                }
1225                                m_broadPhaseBorderBehaviour = _serde::__private::Some(
1226                                    match __A::next_value::<
1227                                        BroadPhaseBorderBehaviour,
1228                                    >(&mut __map) {
1229                                        _serde::__private::Ok(__val) => __val,
1230                                        _serde::__private::Err(__err) => {
1231                                            return _serde::__private::Err(__err);
1232                                        }
1233                                    },
1234                                );
1235                            }
1236                            4usize => {
1237                                if _serde::__private::Option::is_some(
1238                                    &m_mtPostponeAndSortBroadPhaseBorderCallbacks,
1239                                ) {
1240                                    return _serde::__private::Err(
1241                                        <__A::Error as _serde::de::Error>::duplicate_field(
1242                                            "mtPostponeAndSortBroadPhaseBorderCallbacks",
1243                                        ),
1244                                    );
1245                                }
1246                                m_mtPostponeAndSortBroadPhaseBorderCallbacks = _serde::__private::Some(
1247                                    match __A::next_value::<bool>(&mut __map) {
1248                                        _serde::__private::Ok(__val) => __val,
1249                                        _serde::__private::Err(__err) => {
1250                                            return _serde::__private::Err(__err);
1251                                        }
1252                                    },
1253                                );
1254                            }
1255                            5usize => {
1256                                if _serde::__private::Option::is_some(
1257                                    &m_broadPhaseWorldAabb,
1258                                ) {
1259                                    return _serde::__private::Err(
1260                                        <__A::Error as _serde::de::Error>::duplicate_field(
1261                                            "broadPhaseWorldAabb",
1262                                        ),
1263                                    );
1264                                }
1265                                __A::pad(&mut __map, 6usize, 6usize)?;
1266                                m_broadPhaseWorldAabb = _serde::__private::Some(
1267                                    match __A::next_value::<hkAabb>(&mut __map) {
1268                                        _serde::__private::Ok(__val) => __val,
1269                                        _serde::__private::Err(__err) => {
1270                                            return _serde::__private::Err(__err);
1271                                        }
1272                                    },
1273                                );
1274                            }
1275                            6usize => {
1276                                if _serde::__private::Option::is_some(&m_useKdTree) {
1277                                    return _serde::__private::Err(
1278                                        <__A::Error as _serde::de::Error>::duplicate_field(
1279                                            "useKdTree",
1280                                        ),
1281                                    );
1282                                }
1283                                m_useKdTree = _serde::__private::Some(
1284                                    match __A::next_value::<bool>(&mut __map) {
1285                                        _serde::__private::Ok(__val) => __val,
1286                                        _serde::__private::Err(__err) => {
1287                                            return _serde::__private::Err(__err);
1288                                        }
1289                                    },
1290                                );
1291                            }
1292                            7usize => {
1293                                if _serde::__private::Option::is_some(&m_useMultipleTree) {
1294                                    return _serde::__private::Err(
1295                                        <__A::Error as _serde::de::Error>::duplicate_field(
1296                                            "useMultipleTree",
1297                                        ),
1298                                    );
1299                                }
1300                                m_useMultipleTree = _serde::__private::Some(
1301                                    match __A::next_value::<bool>(&mut __map) {
1302                                        _serde::__private::Ok(__val) => __val,
1303                                        _serde::__private::Err(__err) => {
1304                                            return _serde::__private::Err(__err);
1305                                        }
1306                                    },
1307                                );
1308                            }
1309                            8usize => {
1310                                if _serde::__private::Option::is_some(&m_treeUpdateType) {
1311                                    return _serde::__private::Err(
1312                                        <__A::Error as _serde::de::Error>::duplicate_field(
1313                                            "treeUpdateType",
1314                                        ),
1315                                    );
1316                                }
1317                                m_treeUpdateType = _serde::__private::Some(
1318                                    match __A::next_value::<TreeUpdateType>(&mut __map) {
1319                                        _serde::__private::Ok(__val) => __val,
1320                                        _serde::__private::Err(__err) => {
1321                                            return _serde::__private::Err(__err);
1322                                        }
1323                                    },
1324                                );
1325                            }
1326                            9usize => {
1327                                if _serde::__private::Option::is_some(&m_autoUpdateKdTree) {
1328                                    return _serde::__private::Err(
1329                                        <__A::Error as _serde::de::Error>::duplicate_field(
1330                                            "autoUpdateKdTree",
1331                                        ),
1332                                    );
1333                                }
1334                                m_autoUpdateKdTree = _serde::__private::Some(
1335                                    match __A::next_value::<bool>(&mut __map) {
1336                                        _serde::__private::Ok(__val) => __val,
1337                                        _serde::__private::Err(__err) => {
1338                                            return _serde::__private::Err(__err);
1339                                        }
1340                                    },
1341                                );
1342                            }
1343                            10usize => {
1344                                if _serde::__private::Option::is_some(
1345                                    &m_collisionTolerance,
1346                                ) {
1347                                    return _serde::__private::Err(
1348                                        <__A::Error as _serde::de::Error>::duplicate_field(
1349                                            "collisionTolerance",
1350                                        ),
1351                                    );
1352                                }
1353                                m_collisionTolerance = _serde::__private::Some(
1354                                    match __A::next_value::<f32>(&mut __map) {
1355                                        _serde::__private::Ok(__val) => __val,
1356                                        _serde::__private::Err(__err) => {
1357                                            return _serde::__private::Err(__err);
1358                                        }
1359                                    },
1360                                );
1361                            }
1362                            11usize => {
1363                                if _serde::__private::Option::is_some(&m_collisionFilter) {
1364                                    return _serde::__private::Err(
1365                                        <__A::Error as _serde::de::Error>::duplicate_field(
1366                                            "collisionFilter",
1367                                        ),
1368                                    );
1369                                }
1370                                m_collisionFilter = _serde::__private::Some(
1371                                    match __A::next_value::<Pointer>(&mut __map) {
1372                                        _serde::__private::Ok(__val) => __val,
1373                                        _serde::__private::Err(__err) => {
1374                                            return _serde::__private::Err(__err);
1375                                        }
1376                                    },
1377                                );
1378                            }
1379                            12usize => {
1380                                if _serde::__private::Option::is_some(&m_convexListFilter) {
1381                                    return _serde::__private::Err(
1382                                        <__A::Error as _serde::de::Error>::duplicate_field(
1383                                            "convexListFilter",
1384                                        ),
1385                                    );
1386                                }
1387                                m_convexListFilter = _serde::__private::Some(
1388                                    match __A::next_value::<Pointer>(&mut __map) {
1389                                        _serde::__private::Ok(__val) => __val,
1390                                        _serde::__private::Err(__err) => {
1391                                            return _serde::__private::Err(__err);
1392                                        }
1393                                    },
1394                                );
1395                            }
1396                            13usize => {
1397                                if _serde::__private::Option::is_some(
1398                                    &m_expectedMaxLinearVelocity,
1399                                ) {
1400                                    return _serde::__private::Err(
1401                                        <__A::Error as _serde::de::Error>::duplicate_field(
1402                                            "expectedMaxLinearVelocity",
1403                                        ),
1404                                    );
1405                                }
1406                                m_expectedMaxLinearVelocity = _serde::__private::Some(
1407                                    match __A::next_value::<f32>(&mut __map) {
1408                                        _serde::__private::Ok(__val) => __val,
1409                                        _serde::__private::Err(__err) => {
1410                                            return _serde::__private::Err(__err);
1411                                        }
1412                                    },
1413                                );
1414                            }
1415                            14usize => {
1416                                if _serde::__private::Option::is_some(
1417                                    &m_sizeOfToiEventQueue,
1418                                ) {
1419                                    return _serde::__private::Err(
1420                                        <__A::Error as _serde::de::Error>::duplicate_field(
1421                                            "sizeOfToiEventQueue",
1422                                        ),
1423                                    );
1424                                }
1425                                m_sizeOfToiEventQueue = _serde::__private::Some(
1426                                    match __A::next_value::<i32>(&mut __map) {
1427                                        _serde::__private::Ok(__val) => __val,
1428                                        _serde::__private::Err(__err) => {
1429                                            return _serde::__private::Err(__err);
1430                                        }
1431                                    },
1432                                );
1433                            }
1434                            15usize => {
1435                                if _serde::__private::Option::is_some(
1436                                    &m_expectedMinPsiDeltaTime,
1437                                ) {
1438                                    return _serde::__private::Err(
1439                                        <__A::Error as _serde::de::Error>::duplicate_field(
1440                                            "expectedMinPsiDeltaTime",
1441                                        ),
1442                                    );
1443                                }
1444                                m_expectedMinPsiDeltaTime = _serde::__private::Some(
1445                                    match __A::next_value::<f32>(&mut __map) {
1446                                        _serde::__private::Ok(__val) => __val,
1447                                        _serde::__private::Err(__err) => {
1448                                            return _serde::__private::Err(__err);
1449                                        }
1450                                    },
1451                                );
1452                            }
1453                            16usize => {
1454                                if _serde::__private::Option::is_some(&m_memoryWatchDog) {
1455                                    return _serde::__private::Err(
1456                                        <__A::Error as _serde::de::Error>::duplicate_field(
1457                                            "memoryWatchDog",
1458                                        ),
1459                                    );
1460                                }
1461                                __A::pad(&mut __map, 0usize, 4usize)?;
1462                                m_memoryWatchDog = _serde::__private::Some(
1463                                    match __A::next_value::<Pointer>(&mut __map) {
1464                                        _serde::__private::Ok(__val) => __val,
1465                                        _serde::__private::Err(__err) => {
1466                                            return _serde::__private::Err(__err);
1467                                        }
1468                                    },
1469                                );
1470                            }
1471                            17usize => {
1472                                if _serde::__private::Option::is_some(
1473                                    &m_broadPhaseNumMarkers,
1474                                ) {
1475                                    return _serde::__private::Err(
1476                                        <__A::Error as _serde::de::Error>::duplicate_field(
1477                                            "broadPhaseNumMarkers",
1478                                        ),
1479                                    );
1480                                }
1481                                m_broadPhaseNumMarkers = _serde::__private::Some(
1482                                    match __A::next_value::<i32>(&mut __map) {
1483                                        _serde::__private::Ok(__val) => __val,
1484                                        _serde::__private::Err(__err) => {
1485                                            return _serde::__private::Err(__err);
1486                                        }
1487                                    },
1488                                );
1489                            }
1490                            18usize => {
1491                                if _serde::__private::Option::is_some(
1492                                    &m_contactPointGeneration,
1493                                ) {
1494                                    return _serde::__private::Err(
1495                                        <__A::Error as _serde::de::Error>::duplicate_field(
1496                                            "contactPointGeneration",
1497                                        ),
1498                                    );
1499                                }
1500                                m_contactPointGeneration = _serde::__private::Some(
1501                                    match __A::next_value::<
1502                                        ContactPointGeneration,
1503                                    >(&mut __map) {
1504                                        _serde::__private::Ok(__val) => __val,
1505                                        _serde::__private::Err(__err) => {
1506                                            return _serde::__private::Err(__err);
1507                                        }
1508                                    },
1509                                );
1510                            }
1511                            19usize => {
1512                                if _serde::__private::Option::is_some(
1513                                    &m_allowToSkipConfirmedCallbacks,
1514                                ) {
1515                                    return _serde::__private::Err(
1516                                        <__A::Error as _serde::de::Error>::duplicate_field(
1517                                            "allowToSkipConfirmedCallbacks",
1518                                        ),
1519                                    );
1520                                }
1521                                m_allowToSkipConfirmedCallbacks = _serde::__private::Some(
1522                                    match __A::next_value::<bool>(&mut __map) {
1523                                        _serde::__private::Ok(__val) => __val,
1524                                        _serde::__private::Err(__err) => {
1525                                            return _serde::__private::Err(__err);
1526                                        }
1527                                    },
1528                                );
1529                            }
1530                            20usize => {
1531                                if _serde::__private::Option::is_some(
1532                                    &m_useHybridBroadphase,
1533                                ) {
1534                                    return _serde::__private::Err(
1535                                        <__A::Error as _serde::de::Error>::duplicate_field(
1536                                            "useHybridBroadphase",
1537                                        ),
1538                                    );
1539                                }
1540                                m_useHybridBroadphase = _serde::__private::Some(
1541                                    match __A::next_value::<bool>(&mut __map) {
1542                                        _serde::__private::Ok(__val) => __val,
1543                                        _serde::__private::Err(__err) => {
1544                                            return _serde::__private::Err(__err);
1545                                        }
1546                                    },
1547                                );
1548                            }
1549                            21usize => {
1550                                if _serde::__private::Option::is_some(&m_solverTau) {
1551                                    return _serde::__private::Err(
1552                                        <__A::Error as _serde::de::Error>::duplicate_field(
1553                                            "solverTau",
1554                                        ),
1555                                    );
1556                                }
1557                                __A::pad(&mut __map, 1usize, 1usize)?;
1558                                m_solverTau = _serde::__private::Some(
1559                                    match __A::next_value::<f32>(&mut __map) {
1560                                        _serde::__private::Ok(__val) => __val,
1561                                        _serde::__private::Err(__err) => {
1562                                            return _serde::__private::Err(__err);
1563                                        }
1564                                    },
1565                                );
1566                            }
1567                            22usize => {
1568                                if _serde::__private::Option::is_some(&m_solverDamp) {
1569                                    return _serde::__private::Err(
1570                                        <__A::Error as _serde::de::Error>::duplicate_field(
1571                                            "solverDamp",
1572                                        ),
1573                                    );
1574                                }
1575                                m_solverDamp = _serde::__private::Some(
1576                                    match __A::next_value::<f32>(&mut __map) {
1577                                        _serde::__private::Ok(__val) => __val,
1578                                        _serde::__private::Err(__err) => {
1579                                            return _serde::__private::Err(__err);
1580                                        }
1581                                    },
1582                                );
1583                            }
1584                            23usize => {
1585                                if _serde::__private::Option::is_some(&m_solverIterations) {
1586                                    return _serde::__private::Err(
1587                                        <__A::Error as _serde::de::Error>::duplicate_field(
1588                                            "solverIterations",
1589                                        ),
1590                                    );
1591                                }
1592                                m_solverIterations = _serde::__private::Some(
1593                                    match __A::next_value::<i32>(&mut __map) {
1594                                        _serde::__private::Ok(__val) => __val,
1595                                        _serde::__private::Err(__err) => {
1596                                            return _serde::__private::Err(__err);
1597                                        }
1598                                    },
1599                                );
1600                            }
1601                            24usize => {
1602                                if _serde::__private::Option::is_some(&m_solverMicrosteps) {
1603                                    return _serde::__private::Err(
1604                                        <__A::Error as _serde::de::Error>::duplicate_field(
1605                                            "solverMicrosteps",
1606                                        ),
1607                                    );
1608                                }
1609                                m_solverMicrosteps = _serde::__private::Some(
1610                                    match __A::next_value::<i32>(&mut __map) {
1611                                        _serde::__private::Ok(__val) => __val,
1612                                        _serde::__private::Err(__err) => {
1613                                            return _serde::__private::Err(__err);
1614                                        }
1615                                    },
1616                                );
1617                            }
1618                            25usize => {
1619                                if _serde::__private::Option::is_some(
1620                                    &m_maxConstraintViolation,
1621                                ) {
1622                                    return _serde::__private::Err(
1623                                        <__A::Error as _serde::de::Error>::duplicate_field(
1624                                            "maxConstraintViolation",
1625                                        ),
1626                                    );
1627                                }
1628                                m_maxConstraintViolation = _serde::__private::Some(
1629                                    match __A::next_value::<f32>(&mut __map) {
1630                                        _serde::__private::Ok(__val) => __val,
1631                                        _serde::__private::Err(__err) => {
1632                                            return _serde::__private::Err(__err);
1633                                        }
1634                                    },
1635                                );
1636                            }
1637                            26usize => {
1638                                if _serde::__private::Option::is_some(
1639                                    &m_forceCoherentConstraintOrderingInSolver,
1640                                ) {
1641                                    return _serde::__private::Err(
1642                                        <__A::Error as _serde::de::Error>::duplicate_field(
1643                                            "forceCoherentConstraintOrderingInSolver",
1644                                        ),
1645                                    );
1646                                }
1647                                m_forceCoherentConstraintOrderingInSolver = _serde::__private::Some(
1648                                    match __A::next_value::<bool>(&mut __map) {
1649                                        _serde::__private::Ok(__val) => __val,
1650                                        _serde::__private::Err(__err) => {
1651                                            return _serde::__private::Err(__err);
1652                                        }
1653                                    },
1654                                );
1655                            }
1656                            27usize => {
1657                                if _serde::__private::Option::is_some(
1658                                    &m_snapCollisionToConvexEdgeThreshold,
1659                                ) {
1660                                    return _serde::__private::Err(
1661                                        <__A::Error as _serde::de::Error>::duplicate_field(
1662                                            "snapCollisionToConvexEdgeThreshold",
1663                                        ),
1664                                    );
1665                                }
1666                                __A::pad(&mut __map, 3usize, 3usize)?;
1667                                m_snapCollisionToConvexEdgeThreshold = _serde::__private::Some(
1668                                    match __A::next_value::<f32>(&mut __map) {
1669                                        _serde::__private::Ok(__val) => __val,
1670                                        _serde::__private::Err(__err) => {
1671                                            return _serde::__private::Err(__err);
1672                                        }
1673                                    },
1674                                );
1675                            }
1676                            28usize => {
1677                                if _serde::__private::Option::is_some(
1678                                    &m_snapCollisionToConcaveEdgeThreshold,
1679                                ) {
1680                                    return _serde::__private::Err(
1681                                        <__A::Error as _serde::de::Error>::duplicate_field(
1682                                            "snapCollisionToConcaveEdgeThreshold",
1683                                        ),
1684                                    );
1685                                }
1686                                m_snapCollisionToConcaveEdgeThreshold = _serde::__private::Some(
1687                                    match __A::next_value::<f32>(&mut __map) {
1688                                        _serde::__private::Ok(__val) => __val,
1689                                        _serde::__private::Err(__err) => {
1690                                            return _serde::__private::Err(__err);
1691                                        }
1692                                    },
1693                                );
1694                            }
1695                            29usize => {
1696                                if _serde::__private::Option::is_some(
1697                                    &m_enableToiWeldRejection,
1698                                ) {
1699                                    return _serde::__private::Err(
1700                                        <__A::Error as _serde::de::Error>::duplicate_field(
1701                                            "enableToiWeldRejection",
1702                                        ),
1703                                    );
1704                                }
1705                                m_enableToiWeldRejection = _serde::__private::Some(
1706                                    match __A::next_value::<bool>(&mut __map) {
1707                                        _serde::__private::Ok(__val) => __val,
1708                                        _serde::__private::Err(__err) => {
1709                                            return _serde::__private::Err(__err);
1710                                        }
1711                                    },
1712                                );
1713                            }
1714                            30usize => {
1715                                if _serde::__private::Option::is_some(
1716                                    &m_enableDeprecatedWelding,
1717                                ) {
1718                                    return _serde::__private::Err(
1719                                        <__A::Error as _serde::de::Error>::duplicate_field(
1720                                            "enableDeprecatedWelding",
1721                                        ),
1722                                    );
1723                                }
1724                                m_enableDeprecatedWelding = _serde::__private::Some(
1725                                    match __A::next_value::<bool>(&mut __map) {
1726                                        _serde::__private::Ok(__val) => __val,
1727                                        _serde::__private::Err(__err) => {
1728                                            return _serde::__private::Err(__err);
1729                                        }
1730                                    },
1731                                );
1732                            }
1733                            31usize => {
1734                                if _serde::__private::Option::is_some(
1735                                    &m_iterativeLinearCastEarlyOutDistance,
1736                                ) {
1737                                    return _serde::__private::Err(
1738                                        <__A::Error as _serde::de::Error>::duplicate_field(
1739                                            "iterativeLinearCastEarlyOutDistance",
1740                                        ),
1741                                    );
1742                                }
1743                                __A::pad(&mut __map, 2usize, 2usize)?;
1744                                m_iterativeLinearCastEarlyOutDistance = _serde::__private::Some(
1745                                    match __A::next_value::<f32>(&mut __map) {
1746                                        _serde::__private::Ok(__val) => __val,
1747                                        _serde::__private::Err(__err) => {
1748                                            return _serde::__private::Err(__err);
1749                                        }
1750                                    },
1751                                );
1752                            }
1753                            32usize => {
1754                                if _serde::__private::Option::is_some(
1755                                    &m_iterativeLinearCastMaxIterations,
1756                                ) {
1757                                    return _serde::__private::Err(
1758                                        <__A::Error as _serde::de::Error>::duplicate_field(
1759                                            "iterativeLinearCastMaxIterations",
1760                                        ),
1761                                    );
1762                                }
1763                                m_iterativeLinearCastMaxIterations = _serde::__private::Some(
1764                                    match __A::next_value::<i32>(&mut __map) {
1765                                        _serde::__private::Ok(__val) => __val,
1766                                        _serde::__private::Err(__err) => {
1767                                            return _serde::__private::Err(__err);
1768                                        }
1769                                    },
1770                                );
1771                            }
1772                            33usize => {
1773                                if _serde::__private::Option::is_some(
1774                                    &m_deactivationNumInactiveFramesSelectFlag0,
1775                                ) {
1776                                    return _serde::__private::Err(
1777                                        <__A::Error as _serde::de::Error>::duplicate_field(
1778                                            "deactivationNumInactiveFramesSelectFlag0",
1779                                        ),
1780                                    );
1781                                }
1782                                m_deactivationNumInactiveFramesSelectFlag0 = _serde::__private::Some(
1783                                    match __A::next_value::<u8>(&mut __map) {
1784                                        _serde::__private::Ok(__val) => __val,
1785                                        _serde::__private::Err(__err) => {
1786                                            return _serde::__private::Err(__err);
1787                                        }
1788                                    },
1789                                );
1790                            }
1791                            34usize => {
1792                                if _serde::__private::Option::is_some(
1793                                    &m_deactivationNumInactiveFramesSelectFlag1,
1794                                ) {
1795                                    return _serde::__private::Err(
1796                                        <__A::Error as _serde::de::Error>::duplicate_field(
1797                                            "deactivationNumInactiveFramesSelectFlag1",
1798                                        ),
1799                                    );
1800                                }
1801                                m_deactivationNumInactiveFramesSelectFlag1 = _serde::__private::Some(
1802                                    match __A::next_value::<u8>(&mut __map) {
1803                                        _serde::__private::Ok(__val) => __val,
1804                                        _serde::__private::Err(__err) => {
1805                                            return _serde::__private::Err(__err);
1806                                        }
1807                                    },
1808                                );
1809                            }
1810                            35usize => {
1811                                if _serde::__private::Option::is_some(
1812                                    &m_deactivationIntegrateCounter,
1813                                ) {
1814                                    return _serde::__private::Err(
1815                                        <__A::Error as _serde::de::Error>::duplicate_field(
1816                                            "deactivationIntegrateCounter",
1817                                        ),
1818                                    );
1819                                }
1820                                m_deactivationIntegrateCounter = _serde::__private::Some(
1821                                    match __A::next_value::<u8>(&mut __map) {
1822                                        _serde::__private::Ok(__val) => __val,
1823                                        _serde::__private::Err(__err) => {
1824                                            return _serde::__private::Err(__err);
1825                                        }
1826                                    },
1827                                );
1828                            }
1829                            36usize => {
1830                                if _serde::__private::Option::is_some(
1831                                    &m_shouldActivateOnRigidBodyTransformChange,
1832                                ) {
1833                                    return _serde::__private::Err(
1834                                        <__A::Error as _serde::de::Error>::duplicate_field(
1835                                            "shouldActivateOnRigidBodyTransformChange",
1836                                        ),
1837                                    );
1838                                }
1839                                m_shouldActivateOnRigidBodyTransformChange = _serde::__private::Some(
1840                                    match __A::next_value::<bool>(&mut __map) {
1841                                        _serde::__private::Ok(__val) => __val,
1842                                        _serde::__private::Err(__err) => {
1843                                            return _serde::__private::Err(__err);
1844                                        }
1845                                    },
1846                                );
1847                            }
1848                            37usize => {
1849                                if _serde::__private::Option::is_some(
1850                                    &m_deactivationReferenceDistance,
1851                                ) {
1852                                    return _serde::__private::Err(
1853                                        <__A::Error as _serde::de::Error>::duplicate_field(
1854                                            "deactivationReferenceDistance",
1855                                        ),
1856                                    );
1857                                }
1858                                m_deactivationReferenceDistance = _serde::__private::Some(
1859                                    match __A::next_value::<f32>(&mut __map) {
1860                                        _serde::__private::Ok(__val) => __val,
1861                                        _serde::__private::Err(__err) => {
1862                                            return _serde::__private::Err(__err);
1863                                        }
1864                                    },
1865                                );
1866                            }
1867                            38usize => {
1868                                if _serde::__private::Option::is_some(
1869                                    &m_toiCollisionResponseRotateNormal,
1870                                ) {
1871                                    return _serde::__private::Err(
1872                                        <__A::Error as _serde::de::Error>::duplicate_field(
1873                                            "toiCollisionResponseRotateNormal",
1874                                        ),
1875                                    );
1876                                }
1877                                m_toiCollisionResponseRotateNormal = _serde::__private::Some(
1878                                    match __A::next_value::<f32>(&mut __map) {
1879                                        _serde::__private::Ok(__val) => __val,
1880                                        _serde::__private::Err(__err) => {
1881                                            return _serde::__private::Err(__err);
1882                                        }
1883                                    },
1884                                );
1885                            }
1886                            39usize => {
1887                                if _serde::__private::Option::is_some(
1888                                    &m_maxSectorsPerMidphaseCollideTask,
1889                                ) {
1890                                    return _serde::__private::Err(
1891                                        <__A::Error as _serde::de::Error>::duplicate_field(
1892                                            "maxSectorsPerMidphaseCollideTask",
1893                                        ),
1894                                    );
1895                                }
1896                                m_maxSectorsPerMidphaseCollideTask = _serde::__private::Some(
1897                                    match __A::next_value::<i32>(&mut __map) {
1898                                        _serde::__private::Ok(__val) => __val,
1899                                        _serde::__private::Err(__err) => {
1900                                            return _serde::__private::Err(__err);
1901                                        }
1902                                    },
1903                                );
1904                            }
1905                            40usize => {
1906                                if _serde::__private::Option::is_some(
1907                                    &m_maxSectorsPerNarrowphaseCollideTask,
1908                                ) {
1909                                    return _serde::__private::Err(
1910                                        <__A::Error as _serde::de::Error>::duplicate_field(
1911                                            "maxSectorsPerNarrowphaseCollideTask",
1912                                        ),
1913                                    );
1914                                }
1915                                m_maxSectorsPerNarrowphaseCollideTask = _serde::__private::Some(
1916                                    match __A::next_value::<i32>(&mut __map) {
1917                                        _serde::__private::Ok(__val) => __val,
1918                                        _serde::__private::Err(__err) => {
1919                                            return _serde::__private::Err(__err);
1920                                        }
1921                                    },
1922                                );
1923                            }
1924                            41usize => {
1925                                if _serde::__private::Option::is_some(
1926                                    &m_processToisMultithreaded,
1927                                ) {
1928                                    return _serde::__private::Err(
1929                                        <__A::Error as _serde::de::Error>::duplicate_field(
1930                                            "processToisMultithreaded",
1931                                        ),
1932                                    );
1933                                }
1934                                m_processToisMultithreaded = _serde::__private::Some(
1935                                    match __A::next_value::<bool>(&mut __map) {
1936                                        _serde::__private::Ok(__val) => __val,
1937                                        _serde::__private::Err(__err) => {
1938                                            return _serde::__private::Err(__err);
1939                                        }
1940                                    },
1941                                );
1942                            }
1943                            42usize => {
1944                                if _serde::__private::Option::is_some(
1945                                    &m_maxEntriesPerToiMidphaseCollideTask,
1946                                ) {
1947                                    return _serde::__private::Err(
1948                                        <__A::Error as _serde::de::Error>::duplicate_field(
1949                                            "maxEntriesPerToiMidphaseCollideTask",
1950                                        ),
1951                                    );
1952                                }
1953                                __A::pad(&mut __map, 3usize, 3usize)?;
1954                                m_maxEntriesPerToiMidphaseCollideTask = _serde::__private::Some(
1955                                    match __A::next_value::<i32>(&mut __map) {
1956                                        _serde::__private::Ok(__val) => __val,
1957                                        _serde::__private::Err(__err) => {
1958                                            return _serde::__private::Err(__err);
1959                                        }
1960                                    },
1961                                );
1962                            }
1963                            43usize => {
1964                                if _serde::__private::Option::is_some(
1965                                    &m_maxEntriesPerToiNarrowphaseCollideTask,
1966                                ) {
1967                                    return _serde::__private::Err(
1968                                        <__A::Error as _serde::de::Error>::duplicate_field(
1969                                            "maxEntriesPerToiNarrowphaseCollideTask",
1970                                        ),
1971                                    );
1972                                }
1973                                m_maxEntriesPerToiNarrowphaseCollideTask = _serde::__private::Some(
1974                                    match __A::next_value::<i32>(&mut __map) {
1975                                        _serde::__private::Ok(__val) => __val,
1976                                        _serde::__private::Err(__err) => {
1977                                            return _serde::__private::Err(__err);
1978                                        }
1979                                    },
1980                                );
1981                            }
1982                            44usize => {
1983                                if _serde::__private::Option::is_some(
1984                                    &m_maxNumToiCollisionPairsSinglethreaded,
1985                                ) {
1986                                    return _serde::__private::Err(
1987                                        <__A::Error as _serde::de::Error>::duplicate_field(
1988                                            "maxNumToiCollisionPairsSinglethreaded",
1989                                        ),
1990                                    );
1991                                }
1992                                m_maxNumToiCollisionPairsSinglethreaded = _serde::__private::Some(
1993                                    match __A::next_value::<i32>(&mut __map) {
1994                                        _serde::__private::Ok(__val) => __val,
1995                                        _serde::__private::Err(__err) => {
1996                                            return _serde::__private::Err(__err);
1997                                        }
1998                                    },
1999                                );
2000                            }
2001                            45usize => {
2002                                if _serde::__private::Option::is_some(
2003                                    &m_numToisTillAllowedPenetrationSimplifiedToi,
2004                                ) {
2005                                    return _serde::__private::Err(
2006                                        <__A::Error as _serde::de::Error>::duplicate_field(
2007                                            "numToisTillAllowedPenetrationSimplifiedToi",
2008                                        ),
2009                                    );
2010                                }
2011                                m_numToisTillAllowedPenetrationSimplifiedToi = _serde::__private::Some(
2012                                    match __A::next_value::<f32>(&mut __map) {
2013                                        _serde::__private::Ok(__val) => __val,
2014                                        _serde::__private::Err(__err) => {
2015                                            return _serde::__private::Err(__err);
2016                                        }
2017                                    },
2018                                );
2019                            }
2020                            46usize => {
2021                                if _serde::__private::Option::is_some(
2022                                    &m_numToisTillAllowedPenetrationToi,
2023                                ) {
2024                                    return _serde::__private::Err(
2025                                        <__A::Error as _serde::de::Error>::duplicate_field(
2026                                            "numToisTillAllowedPenetrationToi",
2027                                        ),
2028                                    );
2029                                }
2030                                m_numToisTillAllowedPenetrationToi = _serde::__private::Some(
2031                                    match __A::next_value::<f32>(&mut __map) {
2032                                        _serde::__private::Ok(__val) => __val,
2033                                        _serde::__private::Err(__err) => {
2034                                            return _serde::__private::Err(__err);
2035                                        }
2036                                    },
2037                                );
2038                            }
2039                            47usize => {
2040                                if _serde::__private::Option::is_some(
2041                                    &m_numToisTillAllowedPenetrationToiHigher,
2042                                ) {
2043                                    return _serde::__private::Err(
2044                                        <__A::Error as _serde::de::Error>::duplicate_field(
2045                                            "numToisTillAllowedPenetrationToiHigher",
2046                                        ),
2047                                    );
2048                                }
2049                                m_numToisTillAllowedPenetrationToiHigher = _serde::__private::Some(
2050                                    match __A::next_value::<f32>(&mut __map) {
2051                                        _serde::__private::Ok(__val) => __val,
2052                                        _serde::__private::Err(__err) => {
2053                                            return _serde::__private::Err(__err);
2054                                        }
2055                                    },
2056                                );
2057                            }
2058                            48usize => {
2059                                if _serde::__private::Option::is_some(
2060                                    &m_numToisTillAllowedPenetrationToiForced,
2061                                ) {
2062                                    return _serde::__private::Err(
2063                                        <__A::Error as _serde::de::Error>::duplicate_field(
2064                                            "numToisTillAllowedPenetrationToiForced",
2065                                        ),
2066                                    );
2067                                }
2068                                m_numToisTillAllowedPenetrationToiForced = _serde::__private::Some(
2069                                    match __A::next_value::<f32>(&mut __map) {
2070                                        _serde::__private::Ok(__val) => __val,
2071                                        _serde::__private::Err(__err) => {
2072                                            return _serde::__private::Err(__err);
2073                                        }
2074                                    },
2075                                );
2076                            }
2077                            49usize => {
2078                                if _serde::__private::Option::is_some(
2079                                    &m_enableDeactivation,
2080                                ) {
2081                                    return _serde::__private::Err(
2082                                        <__A::Error as _serde::de::Error>::duplicate_field(
2083                                            "enableDeactivation",
2084                                        ),
2085                                    );
2086                                }
2087                                m_enableDeactivation = _serde::__private::Some(
2088                                    match __A::next_value::<bool>(&mut __map) {
2089                                        _serde::__private::Ok(__val) => __val,
2090                                        _serde::__private::Err(__err) => {
2091                                            return _serde::__private::Err(__err);
2092                                        }
2093                                    },
2094                                );
2095                            }
2096                            50usize => {
2097                                if _serde::__private::Option::is_some(&m_simulationType) {
2098                                    return _serde::__private::Err(
2099                                        <__A::Error as _serde::de::Error>::duplicate_field(
2100                                            "simulationType",
2101                                        ),
2102                                    );
2103                                }
2104                                m_simulationType = _serde::__private::Some(
2105                                    match __A::next_value::<SimulationType>(&mut __map) {
2106                                        _serde::__private::Ok(__val) => __val,
2107                                        _serde::__private::Err(__err) => {
2108                                            return _serde::__private::Err(__err);
2109                                        }
2110                                    },
2111                                );
2112                            }
2113                            51usize => {
2114                                if _serde::__private::Option::is_some(
2115                                    &m_enableSimulationIslands,
2116                                ) {
2117                                    return _serde::__private::Err(
2118                                        <__A::Error as _serde::de::Error>::duplicate_field(
2119                                            "enableSimulationIslands",
2120                                        ),
2121                                    );
2122                                }
2123                                m_enableSimulationIslands = _serde::__private::Some(
2124                                    match __A::next_value::<bool>(&mut __map) {
2125                                        _serde::__private::Ok(__val) => __val,
2126                                        _serde::__private::Err(__err) => {
2127                                            return _serde::__private::Err(__err);
2128                                        }
2129                                    },
2130                                );
2131                            }
2132                            52usize => {
2133                                if _serde::__private::Option::is_some(
2134                                    &m_minDesiredIslandSize,
2135                                ) {
2136                                    return _serde::__private::Err(
2137                                        <__A::Error as _serde::de::Error>::duplicate_field(
2138                                            "minDesiredIslandSize",
2139                                        ),
2140                                    );
2141                                }
2142                                __A::pad(&mut __map, 1usize, 1usize)?;
2143                                m_minDesiredIslandSize = _serde::__private::Some(
2144                                    match __A::next_value::<u32>(&mut __map) {
2145                                        _serde::__private::Ok(__val) => __val,
2146                                        _serde::__private::Err(__err) => {
2147                                            return _serde::__private::Err(__err);
2148                                        }
2149                                    },
2150                                );
2151                            }
2152                            53usize => {
2153                                if _serde::__private::Option::is_some(
2154                                    &m_processActionsInSingleThread,
2155                                ) {
2156                                    return _serde::__private::Err(
2157                                        <__A::Error as _serde::de::Error>::duplicate_field(
2158                                            "processActionsInSingleThread",
2159                                        ),
2160                                    );
2161                                }
2162                                m_processActionsInSingleThread = _serde::__private::Some(
2163                                    match __A::next_value::<bool>(&mut __map) {
2164                                        _serde::__private::Ok(__val) => __val,
2165                                        _serde::__private::Err(__err) => {
2166                                            return _serde::__private::Err(__err);
2167                                        }
2168                                    },
2169                                );
2170                            }
2171                            54usize => {
2172                                if _serde::__private::Option::is_some(
2173                                    &m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob,
2174                                ) {
2175                                    return _serde::__private::Err(
2176                                        <__A::Error as _serde::de::Error>::duplicate_field(
2177                                            "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob",
2178                                        ),
2179                                    );
2180                                }
2181                                m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob = _serde::__private::Some(
2182                                    match __A::next_value::<bool>(&mut __map) {
2183                                        _serde::__private::Ok(__val) => __val,
2184                                        _serde::__private::Err(__err) => {
2185                                            return _serde::__private::Err(__err);
2186                                        }
2187                                    },
2188                                );
2189                            }
2190                            55usize => {
2191                                if _serde::__private::Option::is_some(
2192                                    &m_frameMarkerPsiSnap,
2193                                ) {
2194                                    return _serde::__private::Err(
2195                                        <__A::Error as _serde::de::Error>::duplicate_field(
2196                                            "frameMarkerPsiSnap",
2197                                        ),
2198                                    );
2199                                }
2200                                __A::pad(&mut __map, 2usize, 2usize)?;
2201                                m_frameMarkerPsiSnap = _serde::__private::Some(
2202                                    match __A::next_value::<f32>(&mut __map) {
2203                                        _serde::__private::Ok(__val) => __val,
2204                                        _serde::__private::Err(__err) => {
2205                                            return _serde::__private::Err(__err);
2206                                        }
2207                                    },
2208                                );
2209                            }
2210                            56usize => {
2211                                if _serde::__private::Option::is_some(
2212                                    &m_fireCollisionCallbacks,
2213                                ) {
2214                                    return _serde::__private::Err(
2215                                        <__A::Error as _serde::de::Error>::duplicate_field(
2216                                            "fireCollisionCallbacks",
2217                                        ),
2218                                    );
2219                                }
2220                                m_fireCollisionCallbacks = _serde::__private::Some(
2221                                    match __A::next_value::<bool>(&mut __map) {
2222                                        _serde::__private::Ok(__val) => __val,
2223                                        _serde::__private::Err(__err) => {
2224                                            return _serde::__private::Err(__err);
2225                                        }
2226                                    },
2227                                );
2228                            }
2229                            _ => {}
2230                        }
2231                    }
2232                    __A::pad(&mut __map, 7usize, 7usize)?;
2233                    let m_gravity = match m_gravity {
2234                        _serde::__private::Some(__field) => __field,
2235                        _serde::__private::None => {
2236                            return _serde::__private::Err(
2237                                <__A::Error as _serde::de::Error>::missing_field("gravity"),
2238                            );
2239                        }
2240                    };
2241                    let m_broadPhaseQuerySize = match m_broadPhaseQuerySize {
2242                        _serde::__private::Some(__field) => __field,
2243                        _serde::__private::None => {
2244                            return _serde::__private::Err(
2245                                <__A::Error as _serde::de::Error>::missing_field(
2246                                    "broadPhaseQuerySize",
2247                                ),
2248                            );
2249                        }
2250                    };
2251                    let m_contactRestingVelocity = match m_contactRestingVelocity {
2252                        _serde::__private::Some(__field) => __field,
2253                        _serde::__private::None => {
2254                            return _serde::__private::Err(
2255                                <__A::Error as _serde::de::Error>::missing_field(
2256                                    "contactRestingVelocity",
2257                                ),
2258                            );
2259                        }
2260                    };
2261                    let m_broadPhaseBorderBehaviour = match m_broadPhaseBorderBehaviour {
2262                        _serde::__private::Some(__field) => __field,
2263                        _serde::__private::None => {
2264                            return _serde::__private::Err(
2265                                <__A::Error as _serde::de::Error>::missing_field(
2266                                    "broadPhaseBorderBehaviour",
2267                                ),
2268                            );
2269                        }
2270                    };
2271                    let m_mtPostponeAndSortBroadPhaseBorderCallbacks = match m_mtPostponeAndSortBroadPhaseBorderCallbacks {
2272                        _serde::__private::Some(__field) => __field,
2273                        _serde::__private::None => {
2274                            return _serde::__private::Err(
2275                                <__A::Error as _serde::de::Error>::missing_field(
2276                                    "mtPostponeAndSortBroadPhaseBorderCallbacks",
2277                                ),
2278                            );
2279                        }
2280                    };
2281                    let m_broadPhaseWorldAabb = match m_broadPhaseWorldAabb {
2282                        _serde::__private::Some(__field) => __field,
2283                        _serde::__private::None => {
2284                            return _serde::__private::Err(
2285                                <__A::Error as _serde::de::Error>::missing_field(
2286                                    "broadPhaseWorldAabb",
2287                                ),
2288                            );
2289                        }
2290                    };
2291                    let m_useKdTree = match m_useKdTree {
2292                        _serde::__private::Some(__field) => __field,
2293                        _serde::__private::None => {
2294                            return _serde::__private::Err(
2295                                <__A::Error as _serde::de::Error>::missing_field(
2296                                    "useKdTree",
2297                                ),
2298                            );
2299                        }
2300                    };
2301                    let m_useMultipleTree = match m_useMultipleTree {
2302                        _serde::__private::Some(__field) => __field,
2303                        _serde::__private::None => {
2304                            return _serde::__private::Err(
2305                                <__A::Error as _serde::de::Error>::missing_field(
2306                                    "useMultipleTree",
2307                                ),
2308                            );
2309                        }
2310                    };
2311                    let m_treeUpdateType = match m_treeUpdateType {
2312                        _serde::__private::Some(__field) => __field,
2313                        _serde::__private::None => {
2314                            return _serde::__private::Err(
2315                                <__A::Error as _serde::de::Error>::missing_field(
2316                                    "treeUpdateType",
2317                                ),
2318                            );
2319                        }
2320                    };
2321                    let m_autoUpdateKdTree = match m_autoUpdateKdTree {
2322                        _serde::__private::Some(__field) => __field,
2323                        _serde::__private::None => {
2324                            return _serde::__private::Err(
2325                                <__A::Error as _serde::de::Error>::missing_field(
2326                                    "autoUpdateKdTree",
2327                                ),
2328                            );
2329                        }
2330                    };
2331                    let m_collisionTolerance = match m_collisionTolerance {
2332                        _serde::__private::Some(__field) => __field,
2333                        _serde::__private::None => {
2334                            return _serde::__private::Err(
2335                                <__A::Error as _serde::de::Error>::missing_field(
2336                                    "collisionTolerance",
2337                                ),
2338                            );
2339                        }
2340                    };
2341                    let m_collisionFilter = match m_collisionFilter {
2342                        _serde::__private::Some(__field) => __field,
2343                        _serde::__private::None => {
2344                            return _serde::__private::Err(
2345                                <__A::Error as _serde::de::Error>::missing_field(
2346                                    "collisionFilter",
2347                                ),
2348                            );
2349                        }
2350                    };
2351                    let m_convexListFilter = match m_convexListFilter {
2352                        _serde::__private::Some(__field) => __field,
2353                        _serde::__private::None => {
2354                            return _serde::__private::Err(
2355                                <__A::Error as _serde::de::Error>::missing_field(
2356                                    "convexListFilter",
2357                                ),
2358                            );
2359                        }
2360                    };
2361                    let m_expectedMaxLinearVelocity = match m_expectedMaxLinearVelocity {
2362                        _serde::__private::Some(__field) => __field,
2363                        _serde::__private::None => {
2364                            return _serde::__private::Err(
2365                                <__A::Error as _serde::de::Error>::missing_field(
2366                                    "expectedMaxLinearVelocity",
2367                                ),
2368                            );
2369                        }
2370                    };
2371                    let m_sizeOfToiEventQueue = match m_sizeOfToiEventQueue {
2372                        _serde::__private::Some(__field) => __field,
2373                        _serde::__private::None => {
2374                            return _serde::__private::Err(
2375                                <__A::Error as _serde::de::Error>::missing_field(
2376                                    "sizeOfToiEventQueue",
2377                                ),
2378                            );
2379                        }
2380                    };
2381                    let m_expectedMinPsiDeltaTime = match m_expectedMinPsiDeltaTime {
2382                        _serde::__private::Some(__field) => __field,
2383                        _serde::__private::None => {
2384                            return _serde::__private::Err(
2385                                <__A::Error as _serde::de::Error>::missing_field(
2386                                    "expectedMinPsiDeltaTime",
2387                                ),
2388                            );
2389                        }
2390                    };
2391                    let m_memoryWatchDog = match m_memoryWatchDog {
2392                        _serde::__private::Some(__field) => __field,
2393                        _serde::__private::None => {
2394                            return _serde::__private::Err(
2395                                <__A::Error as _serde::de::Error>::missing_field(
2396                                    "memoryWatchDog",
2397                                ),
2398                            );
2399                        }
2400                    };
2401                    let m_broadPhaseNumMarkers = match m_broadPhaseNumMarkers {
2402                        _serde::__private::Some(__field) => __field,
2403                        _serde::__private::None => {
2404                            return _serde::__private::Err(
2405                                <__A::Error as _serde::de::Error>::missing_field(
2406                                    "broadPhaseNumMarkers",
2407                                ),
2408                            );
2409                        }
2410                    };
2411                    let m_contactPointGeneration = match m_contactPointGeneration {
2412                        _serde::__private::Some(__field) => __field,
2413                        _serde::__private::None => {
2414                            return _serde::__private::Err(
2415                                <__A::Error as _serde::de::Error>::missing_field(
2416                                    "contactPointGeneration",
2417                                ),
2418                            );
2419                        }
2420                    };
2421                    let m_allowToSkipConfirmedCallbacks = match m_allowToSkipConfirmedCallbacks {
2422                        _serde::__private::Some(__field) => __field,
2423                        _serde::__private::None => {
2424                            return _serde::__private::Err(
2425                                <__A::Error as _serde::de::Error>::missing_field(
2426                                    "allowToSkipConfirmedCallbacks",
2427                                ),
2428                            );
2429                        }
2430                    };
2431                    let m_useHybridBroadphase = match m_useHybridBroadphase {
2432                        _serde::__private::Some(__field) => __field,
2433                        _serde::__private::None => {
2434                            return _serde::__private::Err(
2435                                <__A::Error as _serde::de::Error>::missing_field(
2436                                    "useHybridBroadphase",
2437                                ),
2438                            );
2439                        }
2440                    };
2441                    let m_solverTau = match m_solverTau {
2442                        _serde::__private::Some(__field) => __field,
2443                        _serde::__private::None => {
2444                            return _serde::__private::Err(
2445                                <__A::Error as _serde::de::Error>::missing_field(
2446                                    "solverTau",
2447                                ),
2448                            );
2449                        }
2450                    };
2451                    let m_solverDamp = match m_solverDamp {
2452                        _serde::__private::Some(__field) => __field,
2453                        _serde::__private::None => {
2454                            return _serde::__private::Err(
2455                                <__A::Error as _serde::de::Error>::missing_field(
2456                                    "solverDamp",
2457                                ),
2458                            );
2459                        }
2460                    };
2461                    let m_solverIterations = match m_solverIterations {
2462                        _serde::__private::Some(__field) => __field,
2463                        _serde::__private::None => {
2464                            return _serde::__private::Err(
2465                                <__A::Error as _serde::de::Error>::missing_field(
2466                                    "solverIterations",
2467                                ),
2468                            );
2469                        }
2470                    };
2471                    let m_solverMicrosteps = match m_solverMicrosteps {
2472                        _serde::__private::Some(__field) => __field,
2473                        _serde::__private::None => {
2474                            return _serde::__private::Err(
2475                                <__A::Error as _serde::de::Error>::missing_field(
2476                                    "solverMicrosteps",
2477                                ),
2478                            );
2479                        }
2480                    };
2481                    let m_maxConstraintViolation = match m_maxConstraintViolation {
2482                        _serde::__private::Some(__field) => __field,
2483                        _serde::__private::None => {
2484                            return _serde::__private::Err(
2485                                <__A::Error as _serde::de::Error>::missing_field(
2486                                    "maxConstraintViolation",
2487                                ),
2488                            );
2489                        }
2490                    };
2491                    let m_forceCoherentConstraintOrderingInSolver = match m_forceCoherentConstraintOrderingInSolver {
2492                        _serde::__private::Some(__field) => __field,
2493                        _serde::__private::None => {
2494                            return _serde::__private::Err(
2495                                <__A::Error as _serde::de::Error>::missing_field(
2496                                    "forceCoherentConstraintOrderingInSolver",
2497                                ),
2498                            );
2499                        }
2500                    };
2501                    let m_snapCollisionToConvexEdgeThreshold = match m_snapCollisionToConvexEdgeThreshold {
2502                        _serde::__private::Some(__field) => __field,
2503                        _serde::__private::None => {
2504                            return _serde::__private::Err(
2505                                <__A::Error as _serde::de::Error>::missing_field(
2506                                    "snapCollisionToConvexEdgeThreshold",
2507                                ),
2508                            );
2509                        }
2510                    };
2511                    let m_snapCollisionToConcaveEdgeThreshold = match m_snapCollisionToConcaveEdgeThreshold {
2512                        _serde::__private::Some(__field) => __field,
2513                        _serde::__private::None => {
2514                            return _serde::__private::Err(
2515                                <__A::Error as _serde::de::Error>::missing_field(
2516                                    "snapCollisionToConcaveEdgeThreshold",
2517                                ),
2518                            );
2519                        }
2520                    };
2521                    let m_enableToiWeldRejection = match m_enableToiWeldRejection {
2522                        _serde::__private::Some(__field) => __field,
2523                        _serde::__private::None => {
2524                            return _serde::__private::Err(
2525                                <__A::Error as _serde::de::Error>::missing_field(
2526                                    "enableToiWeldRejection",
2527                                ),
2528                            );
2529                        }
2530                    };
2531                    let m_enableDeprecatedWelding = match m_enableDeprecatedWelding {
2532                        _serde::__private::Some(__field) => __field,
2533                        _serde::__private::None => {
2534                            return _serde::__private::Err(
2535                                <__A::Error as _serde::de::Error>::missing_field(
2536                                    "enableDeprecatedWelding",
2537                                ),
2538                            );
2539                        }
2540                    };
2541                    let m_iterativeLinearCastEarlyOutDistance = match m_iterativeLinearCastEarlyOutDistance {
2542                        _serde::__private::Some(__field) => __field,
2543                        _serde::__private::None => {
2544                            return _serde::__private::Err(
2545                                <__A::Error as _serde::de::Error>::missing_field(
2546                                    "iterativeLinearCastEarlyOutDistance",
2547                                ),
2548                            );
2549                        }
2550                    };
2551                    let m_iterativeLinearCastMaxIterations = match m_iterativeLinearCastMaxIterations {
2552                        _serde::__private::Some(__field) => __field,
2553                        _serde::__private::None => {
2554                            return _serde::__private::Err(
2555                                <__A::Error as _serde::de::Error>::missing_field(
2556                                    "iterativeLinearCastMaxIterations",
2557                                ),
2558                            );
2559                        }
2560                    };
2561                    let m_deactivationNumInactiveFramesSelectFlag0 = match m_deactivationNumInactiveFramesSelectFlag0 {
2562                        _serde::__private::Some(__field) => __field,
2563                        _serde::__private::None => {
2564                            return _serde::__private::Err(
2565                                <__A::Error as _serde::de::Error>::missing_field(
2566                                    "deactivationNumInactiveFramesSelectFlag0",
2567                                ),
2568                            );
2569                        }
2570                    };
2571                    let m_deactivationNumInactiveFramesSelectFlag1 = match m_deactivationNumInactiveFramesSelectFlag1 {
2572                        _serde::__private::Some(__field) => __field,
2573                        _serde::__private::None => {
2574                            return _serde::__private::Err(
2575                                <__A::Error as _serde::de::Error>::missing_field(
2576                                    "deactivationNumInactiveFramesSelectFlag1",
2577                                ),
2578                            );
2579                        }
2580                    };
2581                    let m_deactivationIntegrateCounter = match m_deactivationIntegrateCounter {
2582                        _serde::__private::Some(__field) => __field,
2583                        _serde::__private::None => {
2584                            return _serde::__private::Err(
2585                                <__A::Error as _serde::de::Error>::missing_field(
2586                                    "deactivationIntegrateCounter",
2587                                ),
2588                            );
2589                        }
2590                    };
2591                    let m_shouldActivateOnRigidBodyTransformChange = match m_shouldActivateOnRigidBodyTransformChange {
2592                        _serde::__private::Some(__field) => __field,
2593                        _serde::__private::None => {
2594                            return _serde::__private::Err(
2595                                <__A::Error as _serde::de::Error>::missing_field(
2596                                    "shouldActivateOnRigidBodyTransformChange",
2597                                ),
2598                            );
2599                        }
2600                    };
2601                    let m_deactivationReferenceDistance = match m_deactivationReferenceDistance {
2602                        _serde::__private::Some(__field) => __field,
2603                        _serde::__private::None => {
2604                            return _serde::__private::Err(
2605                                <__A::Error as _serde::de::Error>::missing_field(
2606                                    "deactivationReferenceDistance",
2607                                ),
2608                            );
2609                        }
2610                    };
2611                    let m_toiCollisionResponseRotateNormal = match m_toiCollisionResponseRotateNormal {
2612                        _serde::__private::Some(__field) => __field,
2613                        _serde::__private::None => {
2614                            return _serde::__private::Err(
2615                                <__A::Error as _serde::de::Error>::missing_field(
2616                                    "toiCollisionResponseRotateNormal",
2617                                ),
2618                            );
2619                        }
2620                    };
2621                    let m_maxSectorsPerMidphaseCollideTask = match m_maxSectorsPerMidphaseCollideTask {
2622                        _serde::__private::Some(__field) => __field,
2623                        _serde::__private::None => {
2624                            return _serde::__private::Err(
2625                                <__A::Error as _serde::de::Error>::missing_field(
2626                                    "maxSectorsPerMidphaseCollideTask",
2627                                ),
2628                            );
2629                        }
2630                    };
2631                    let m_maxSectorsPerNarrowphaseCollideTask = match m_maxSectorsPerNarrowphaseCollideTask {
2632                        _serde::__private::Some(__field) => __field,
2633                        _serde::__private::None => {
2634                            return _serde::__private::Err(
2635                                <__A::Error as _serde::de::Error>::missing_field(
2636                                    "maxSectorsPerNarrowphaseCollideTask",
2637                                ),
2638                            );
2639                        }
2640                    };
2641                    let m_processToisMultithreaded = match m_processToisMultithreaded {
2642                        _serde::__private::Some(__field) => __field,
2643                        _serde::__private::None => {
2644                            return _serde::__private::Err(
2645                                <__A::Error as _serde::de::Error>::missing_field(
2646                                    "processToisMultithreaded",
2647                                ),
2648                            );
2649                        }
2650                    };
2651                    let m_maxEntriesPerToiMidphaseCollideTask = match m_maxEntriesPerToiMidphaseCollideTask {
2652                        _serde::__private::Some(__field) => __field,
2653                        _serde::__private::None => {
2654                            return _serde::__private::Err(
2655                                <__A::Error as _serde::de::Error>::missing_field(
2656                                    "maxEntriesPerToiMidphaseCollideTask",
2657                                ),
2658                            );
2659                        }
2660                    };
2661                    let m_maxEntriesPerToiNarrowphaseCollideTask = match m_maxEntriesPerToiNarrowphaseCollideTask {
2662                        _serde::__private::Some(__field) => __field,
2663                        _serde::__private::None => {
2664                            return _serde::__private::Err(
2665                                <__A::Error as _serde::de::Error>::missing_field(
2666                                    "maxEntriesPerToiNarrowphaseCollideTask",
2667                                ),
2668                            );
2669                        }
2670                    };
2671                    let m_maxNumToiCollisionPairsSinglethreaded = match m_maxNumToiCollisionPairsSinglethreaded {
2672                        _serde::__private::Some(__field) => __field,
2673                        _serde::__private::None => {
2674                            return _serde::__private::Err(
2675                                <__A::Error as _serde::de::Error>::missing_field(
2676                                    "maxNumToiCollisionPairsSinglethreaded",
2677                                ),
2678                            );
2679                        }
2680                    };
2681                    let m_numToisTillAllowedPenetrationSimplifiedToi = match m_numToisTillAllowedPenetrationSimplifiedToi {
2682                        _serde::__private::Some(__field) => __field,
2683                        _serde::__private::None => {
2684                            return _serde::__private::Err(
2685                                <__A::Error as _serde::de::Error>::missing_field(
2686                                    "numToisTillAllowedPenetrationSimplifiedToi",
2687                                ),
2688                            );
2689                        }
2690                    };
2691                    let m_numToisTillAllowedPenetrationToi = match m_numToisTillAllowedPenetrationToi {
2692                        _serde::__private::Some(__field) => __field,
2693                        _serde::__private::None => {
2694                            return _serde::__private::Err(
2695                                <__A::Error as _serde::de::Error>::missing_field(
2696                                    "numToisTillAllowedPenetrationToi",
2697                                ),
2698                            );
2699                        }
2700                    };
2701                    let m_numToisTillAllowedPenetrationToiHigher = match m_numToisTillAllowedPenetrationToiHigher {
2702                        _serde::__private::Some(__field) => __field,
2703                        _serde::__private::None => {
2704                            return _serde::__private::Err(
2705                                <__A::Error as _serde::de::Error>::missing_field(
2706                                    "numToisTillAllowedPenetrationToiHigher",
2707                                ),
2708                            );
2709                        }
2710                    };
2711                    let m_numToisTillAllowedPenetrationToiForced = match m_numToisTillAllowedPenetrationToiForced {
2712                        _serde::__private::Some(__field) => __field,
2713                        _serde::__private::None => {
2714                            return _serde::__private::Err(
2715                                <__A::Error as _serde::de::Error>::missing_field(
2716                                    "numToisTillAllowedPenetrationToiForced",
2717                                ),
2718                            );
2719                        }
2720                    };
2721                    let m_enableDeactivation = match m_enableDeactivation {
2722                        _serde::__private::Some(__field) => __field,
2723                        _serde::__private::None => {
2724                            return _serde::__private::Err(
2725                                <__A::Error as _serde::de::Error>::missing_field(
2726                                    "enableDeactivation",
2727                                ),
2728                            );
2729                        }
2730                    };
2731                    let m_simulationType = match m_simulationType {
2732                        _serde::__private::Some(__field) => __field,
2733                        _serde::__private::None => {
2734                            return _serde::__private::Err(
2735                                <__A::Error as _serde::de::Error>::missing_field(
2736                                    "simulationType",
2737                                ),
2738                            );
2739                        }
2740                    };
2741                    let m_enableSimulationIslands = match m_enableSimulationIslands {
2742                        _serde::__private::Some(__field) => __field,
2743                        _serde::__private::None => {
2744                            return _serde::__private::Err(
2745                                <__A::Error as _serde::de::Error>::missing_field(
2746                                    "enableSimulationIslands",
2747                                ),
2748                            );
2749                        }
2750                    };
2751                    let m_minDesiredIslandSize = match m_minDesiredIslandSize {
2752                        _serde::__private::Some(__field) => __field,
2753                        _serde::__private::None => {
2754                            return _serde::__private::Err(
2755                                <__A::Error as _serde::de::Error>::missing_field(
2756                                    "minDesiredIslandSize",
2757                                ),
2758                            );
2759                        }
2760                    };
2761                    let m_processActionsInSingleThread = match m_processActionsInSingleThread {
2762                        _serde::__private::Some(__field) => __field,
2763                        _serde::__private::None => {
2764                            return _serde::__private::Err(
2765                                <__A::Error as _serde::de::Error>::missing_field(
2766                                    "processActionsInSingleThread",
2767                                ),
2768                            );
2769                        }
2770                    };
2771                    let m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob = match m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob {
2772                        _serde::__private::Some(__field) => __field,
2773                        _serde::__private::None => {
2774                            return _serde::__private::Err(
2775                                <__A::Error as _serde::de::Error>::missing_field(
2776                                    "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob",
2777                                ),
2778                            );
2779                        }
2780                    };
2781                    let m_frameMarkerPsiSnap = match m_frameMarkerPsiSnap {
2782                        _serde::__private::Some(__field) => __field,
2783                        _serde::__private::None => {
2784                            return _serde::__private::Err(
2785                                <__A::Error as _serde::de::Error>::missing_field(
2786                                    "frameMarkerPsiSnap",
2787                                ),
2788                            );
2789                        }
2790                    };
2791                    let m_fireCollisionCallbacks = match m_fireCollisionCallbacks {
2792                        _serde::__private::Some(__field) => __field,
2793                        _serde::__private::None => {
2794                            return _serde::__private::Err(
2795                                <__A::Error as _serde::de::Error>::missing_field(
2796                                    "fireCollisionCallbacks",
2797                                ),
2798                            );
2799                        }
2800                    };
2801                    _serde::__private::Ok(hkpWorldCinfo {
2802                        __ptr,
2803                        parent,
2804                        m_gravity,
2805                        m_broadPhaseQuerySize,
2806                        m_contactRestingVelocity,
2807                        m_broadPhaseBorderBehaviour,
2808                        m_mtPostponeAndSortBroadPhaseBorderCallbacks,
2809                        m_broadPhaseWorldAabb,
2810                        m_useKdTree,
2811                        m_useMultipleTree,
2812                        m_treeUpdateType,
2813                        m_autoUpdateKdTree,
2814                        m_collisionTolerance,
2815                        m_collisionFilter,
2816                        m_convexListFilter,
2817                        m_expectedMaxLinearVelocity,
2818                        m_sizeOfToiEventQueue,
2819                        m_expectedMinPsiDeltaTime,
2820                        m_memoryWatchDog,
2821                        m_broadPhaseNumMarkers,
2822                        m_contactPointGeneration,
2823                        m_allowToSkipConfirmedCallbacks,
2824                        m_useHybridBroadphase,
2825                        m_solverTau,
2826                        m_solverDamp,
2827                        m_solverIterations,
2828                        m_solverMicrosteps,
2829                        m_maxConstraintViolation,
2830                        m_forceCoherentConstraintOrderingInSolver,
2831                        m_snapCollisionToConvexEdgeThreshold,
2832                        m_snapCollisionToConcaveEdgeThreshold,
2833                        m_enableToiWeldRejection,
2834                        m_enableDeprecatedWelding,
2835                        m_iterativeLinearCastEarlyOutDistance,
2836                        m_iterativeLinearCastMaxIterations,
2837                        m_deactivationNumInactiveFramesSelectFlag0,
2838                        m_deactivationNumInactiveFramesSelectFlag1,
2839                        m_deactivationIntegrateCounter,
2840                        m_shouldActivateOnRigidBodyTransformChange,
2841                        m_deactivationReferenceDistance,
2842                        m_toiCollisionResponseRotateNormal,
2843                        m_maxSectorsPerMidphaseCollideTask,
2844                        m_maxSectorsPerNarrowphaseCollideTask,
2845                        m_processToisMultithreaded,
2846                        m_maxEntriesPerToiMidphaseCollideTask,
2847                        m_maxEntriesPerToiNarrowphaseCollideTask,
2848                        m_maxNumToiCollisionPairsSinglethreaded,
2849                        m_numToisTillAllowedPenetrationSimplifiedToi,
2850                        m_numToisTillAllowedPenetrationToi,
2851                        m_numToisTillAllowedPenetrationToiHigher,
2852                        m_numToisTillAllowedPenetrationToiForced,
2853                        m_enableDeactivation,
2854                        m_simulationType,
2855                        m_enableSimulationIslands,
2856                        m_minDesiredIslandSize,
2857                        m_processActionsInSingleThread,
2858                        m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob,
2859                        m_frameMarkerPsiSnap,
2860                        m_fireCollisionCallbacks,
2861                    })
2862                }
2863                #[allow(clippy::manual_unwrap_or_default)]
2864                fn visit_struct<__A>(
2865                    self,
2866                    mut __map: __A,
2867                ) -> _serde::__private::Result<Self::Value, __A::Error>
2868                where
2869                    __A: _serde::de::MapAccess<'de>,
2870                {
2871                    let mut m_gravity: _serde::__private::Option<Vector4> = _serde::__private::None;
2872                    let mut m_broadPhaseQuerySize: _serde::__private::Option<i32> = _serde::__private::None;
2873                    let mut m_contactRestingVelocity: _serde::__private::Option<f32> = _serde::__private::None;
2874                    let mut m_broadPhaseBorderBehaviour: _serde::__private::Option<
2875                        BroadPhaseBorderBehaviour,
2876                    > = _serde::__private::None;
2877                    let mut m_mtPostponeAndSortBroadPhaseBorderCallbacks: _serde::__private::Option<
2878                        bool,
2879                    > = _serde::__private::None;
2880                    let mut m_broadPhaseWorldAabb: _serde::__private::Option<hkAabb> = _serde::__private::None;
2881                    let mut m_useKdTree: _serde::__private::Option<bool> = _serde::__private::None;
2882                    let mut m_useMultipleTree: _serde::__private::Option<bool> = _serde::__private::None;
2883                    let mut m_treeUpdateType: _serde::__private::Option<
2884                        TreeUpdateType,
2885                    > = _serde::__private::None;
2886                    let mut m_autoUpdateKdTree: _serde::__private::Option<bool> = _serde::__private::None;
2887                    let mut m_collisionTolerance: _serde::__private::Option<f32> = _serde::__private::None;
2888                    let mut m_collisionFilter: _serde::__private::Option<Pointer> = _serde::__private::None;
2889                    let mut m_convexListFilter: _serde::__private::Option<Pointer> = _serde::__private::None;
2890                    let mut m_expectedMaxLinearVelocity: _serde::__private::Option<
2891                        f32,
2892                    > = _serde::__private::None;
2893                    let mut m_sizeOfToiEventQueue: _serde::__private::Option<i32> = _serde::__private::None;
2894                    let mut m_expectedMinPsiDeltaTime: _serde::__private::Option<f32> = _serde::__private::None;
2895                    let mut m_memoryWatchDog: _serde::__private::Option<Pointer> = _serde::__private::None;
2896                    let mut m_broadPhaseNumMarkers: _serde::__private::Option<i32> = _serde::__private::None;
2897                    let mut m_contactPointGeneration: _serde::__private::Option<
2898                        ContactPointGeneration,
2899                    > = _serde::__private::None;
2900                    let mut m_allowToSkipConfirmedCallbacks: _serde::__private::Option<
2901                        bool,
2902                    > = _serde::__private::None;
2903                    let mut m_useHybridBroadphase: _serde::__private::Option<bool> = _serde::__private::None;
2904                    let mut m_solverTau: _serde::__private::Option<f32> = _serde::__private::None;
2905                    let mut m_solverDamp: _serde::__private::Option<f32> = _serde::__private::None;
2906                    let mut m_solverIterations: _serde::__private::Option<i32> = _serde::__private::None;
2907                    let mut m_solverMicrosteps: _serde::__private::Option<i32> = _serde::__private::None;
2908                    let mut m_maxConstraintViolation: _serde::__private::Option<f32> = _serde::__private::None;
2909                    let mut m_forceCoherentConstraintOrderingInSolver: _serde::__private::Option<
2910                        bool,
2911                    > = _serde::__private::None;
2912                    let mut m_snapCollisionToConvexEdgeThreshold: _serde::__private::Option<
2913                        f32,
2914                    > = _serde::__private::None;
2915                    let mut m_snapCollisionToConcaveEdgeThreshold: _serde::__private::Option<
2916                        f32,
2917                    > = _serde::__private::None;
2918                    let mut m_enableToiWeldRejection: _serde::__private::Option<bool> = _serde::__private::None;
2919                    let mut m_enableDeprecatedWelding: _serde::__private::Option<bool> = _serde::__private::None;
2920                    let mut m_iterativeLinearCastEarlyOutDistance: _serde::__private::Option<
2921                        f32,
2922                    > = _serde::__private::None;
2923                    let mut m_iterativeLinearCastMaxIterations: _serde::__private::Option<
2924                        i32,
2925                    > = _serde::__private::None;
2926                    let mut m_deactivationNumInactiveFramesSelectFlag0: _serde::__private::Option<
2927                        u8,
2928                    > = _serde::__private::None;
2929                    let mut m_deactivationNumInactiveFramesSelectFlag1: _serde::__private::Option<
2930                        u8,
2931                    > = _serde::__private::None;
2932                    let mut m_deactivationIntegrateCounter: _serde::__private::Option<
2933                        u8,
2934                    > = _serde::__private::None;
2935                    let mut m_shouldActivateOnRigidBodyTransformChange: _serde::__private::Option<
2936                        bool,
2937                    > = _serde::__private::None;
2938                    let mut m_deactivationReferenceDistance: _serde::__private::Option<
2939                        f32,
2940                    > = _serde::__private::None;
2941                    let mut m_toiCollisionResponseRotateNormal: _serde::__private::Option<
2942                        f32,
2943                    > = _serde::__private::None;
2944                    let mut m_maxSectorsPerMidphaseCollideTask: _serde::__private::Option<
2945                        i32,
2946                    > = _serde::__private::None;
2947                    let mut m_maxSectorsPerNarrowphaseCollideTask: _serde::__private::Option<
2948                        i32,
2949                    > = _serde::__private::None;
2950                    let mut m_processToisMultithreaded: _serde::__private::Option<
2951                        bool,
2952                    > = _serde::__private::None;
2953                    let mut m_maxEntriesPerToiMidphaseCollideTask: _serde::__private::Option<
2954                        i32,
2955                    > = _serde::__private::None;
2956                    let mut m_maxEntriesPerToiNarrowphaseCollideTask: _serde::__private::Option<
2957                        i32,
2958                    > = _serde::__private::None;
2959                    let mut m_maxNumToiCollisionPairsSinglethreaded: _serde::__private::Option<
2960                        i32,
2961                    > = _serde::__private::None;
2962                    let mut m_numToisTillAllowedPenetrationSimplifiedToi: _serde::__private::Option<
2963                        f32,
2964                    > = _serde::__private::None;
2965                    let mut m_numToisTillAllowedPenetrationToi: _serde::__private::Option<
2966                        f32,
2967                    > = _serde::__private::None;
2968                    let mut m_numToisTillAllowedPenetrationToiHigher: _serde::__private::Option<
2969                        f32,
2970                    > = _serde::__private::None;
2971                    let mut m_numToisTillAllowedPenetrationToiForced: _serde::__private::Option<
2972                        f32,
2973                    > = _serde::__private::None;
2974                    let mut m_enableDeactivation: _serde::__private::Option<bool> = _serde::__private::None;
2975                    let mut m_simulationType: _serde::__private::Option<
2976                        SimulationType,
2977                    > = _serde::__private::None;
2978                    let mut m_enableSimulationIslands: _serde::__private::Option<bool> = _serde::__private::None;
2979                    let mut m_minDesiredIslandSize: _serde::__private::Option<u32> = _serde::__private::None;
2980                    let mut m_processActionsInSingleThread: _serde::__private::Option<
2981                        bool,
2982                    > = _serde::__private::None;
2983                    let mut m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob: _serde::__private::Option<
2984                        bool,
2985                    > = _serde::__private::None;
2986                    let mut m_frameMarkerPsiSnap: _serde::__private::Option<f32> = _serde::__private::None;
2987                    let mut m_fireCollisionCallbacks: _serde::__private::Option<bool> = _serde::__private::None;
2988                    while let _serde::__private::Some(__key) = {
2989                        __A::next_key::<__Field>(&mut __map)?
2990                    } {
2991                        match __key {
2992                            __Field::m_gravity => {
2993                                #[cfg(
2994                                    any(feature = "strict", feature = "ignore_duplicates")
2995                                )]
2996                                if _serde::__private::Option::is_some(&m_gravity) {
2997                                    #[cfg(feature = "ignore_duplicates")]
2998                                    {
2999                                        __A::skip_value(&mut __map)?;
3000                                        continue;
3001                                    }
3002                                    #[cfg(feature = "strict")]
3003                                    return _serde::__private::Err(
3004                                        <__A::Error as _serde::de::Error>::duplicate_field(
3005                                            "gravity",
3006                                        ),
3007                                    );
3008                                }
3009                                m_gravity = _serde::__private::Some(
3010                                    match __A::next_value::<Vector4>(&mut __map) {
3011                                        _serde::__private::Ok(__val) => __val,
3012                                        _serde::__private::Err(__err) => {
3013                                            return _serde::__private::Err(__err);
3014                                        }
3015                                    },
3016                                );
3017                            }
3018                            __Field::m_broadPhaseQuerySize => {
3019                                #[cfg(
3020                                    any(feature = "strict", feature = "ignore_duplicates")
3021                                )]
3022                                if _serde::__private::Option::is_some(
3023                                    &m_broadPhaseQuerySize,
3024                                ) {
3025                                    #[cfg(feature = "ignore_duplicates")]
3026                                    {
3027                                        __A::skip_value(&mut __map)?;
3028                                        continue;
3029                                    }
3030                                    #[cfg(feature = "strict")]
3031                                    return _serde::__private::Err(
3032                                        <__A::Error as _serde::de::Error>::duplicate_field(
3033                                            "broadPhaseQuerySize",
3034                                        ),
3035                                    );
3036                                }
3037                                m_broadPhaseQuerySize = _serde::__private::Some(
3038                                    match __A::next_value::<i32>(&mut __map) {
3039                                        _serde::__private::Ok(__val) => __val,
3040                                        _serde::__private::Err(__err) => {
3041                                            return _serde::__private::Err(__err);
3042                                        }
3043                                    },
3044                                );
3045                            }
3046                            __Field::m_contactRestingVelocity => {
3047                                #[cfg(
3048                                    any(feature = "strict", feature = "ignore_duplicates")
3049                                )]
3050                                if _serde::__private::Option::is_some(
3051                                    &m_contactRestingVelocity,
3052                                ) {
3053                                    #[cfg(feature = "ignore_duplicates")]
3054                                    {
3055                                        __A::skip_value(&mut __map)?;
3056                                        continue;
3057                                    }
3058                                    #[cfg(feature = "strict")]
3059                                    return _serde::__private::Err(
3060                                        <__A::Error as _serde::de::Error>::duplicate_field(
3061                                            "contactRestingVelocity",
3062                                        ),
3063                                    );
3064                                }
3065                                m_contactRestingVelocity = _serde::__private::Some(
3066                                    match __A::next_value::<f32>(&mut __map) {
3067                                        _serde::__private::Ok(__val) => __val,
3068                                        _serde::__private::Err(__err) => {
3069                                            return _serde::__private::Err(__err);
3070                                        }
3071                                    },
3072                                );
3073                            }
3074                            __Field::m_broadPhaseBorderBehaviour => {
3075                                #[cfg(
3076                                    any(feature = "strict", feature = "ignore_duplicates")
3077                                )]
3078                                if _serde::__private::Option::is_some(
3079                                    &m_broadPhaseBorderBehaviour,
3080                                ) {
3081                                    #[cfg(feature = "ignore_duplicates")]
3082                                    {
3083                                        __A::skip_value(&mut __map)?;
3084                                        continue;
3085                                    }
3086                                    #[cfg(feature = "strict")]
3087                                    return _serde::__private::Err(
3088                                        <__A::Error as _serde::de::Error>::duplicate_field(
3089                                            "broadPhaseBorderBehaviour",
3090                                        ),
3091                                    );
3092                                }
3093                                m_broadPhaseBorderBehaviour = _serde::__private::Some(
3094                                    match __A::next_value::<
3095                                        BroadPhaseBorderBehaviour,
3096                                    >(&mut __map) {
3097                                        _serde::__private::Ok(__val) => __val,
3098                                        _serde::__private::Err(__err) => {
3099                                            return _serde::__private::Err(__err);
3100                                        }
3101                                    },
3102                                );
3103                            }
3104                            __Field::m_mtPostponeAndSortBroadPhaseBorderCallbacks => {
3105                                #[cfg(
3106                                    any(feature = "strict", feature = "ignore_duplicates")
3107                                )]
3108                                if _serde::__private::Option::is_some(
3109                                    &m_mtPostponeAndSortBroadPhaseBorderCallbacks,
3110                                ) {
3111                                    #[cfg(feature = "ignore_duplicates")]
3112                                    {
3113                                        __A::skip_value(&mut __map)?;
3114                                        continue;
3115                                    }
3116                                    #[cfg(feature = "strict")]
3117                                    return _serde::__private::Err(
3118                                        <__A::Error as _serde::de::Error>::duplicate_field(
3119                                            "mtPostponeAndSortBroadPhaseBorderCallbacks",
3120                                        ),
3121                                    );
3122                                }
3123                                m_mtPostponeAndSortBroadPhaseBorderCallbacks = _serde::__private::Some(
3124                                    match __A::next_value::<bool>(&mut __map) {
3125                                        _serde::__private::Ok(__val) => __val,
3126                                        _serde::__private::Err(__err) => {
3127                                            return _serde::__private::Err(__err);
3128                                        }
3129                                    },
3130                                );
3131                            }
3132                            __Field::m_broadPhaseWorldAabb => {
3133                                #[cfg(
3134                                    any(feature = "strict", feature = "ignore_duplicates")
3135                                )]
3136                                if _serde::__private::Option::is_some(
3137                                    &m_broadPhaseWorldAabb,
3138                                ) {
3139                                    #[cfg(feature = "ignore_duplicates")]
3140                                    {
3141                                        __A::skip_value(&mut __map)?;
3142                                        continue;
3143                                    }
3144                                    #[cfg(feature = "strict")]
3145                                    return _serde::__private::Err(
3146                                        <__A::Error as _serde::de::Error>::duplicate_field(
3147                                            "broadPhaseWorldAabb",
3148                                        ),
3149                                    );
3150                                }
3151                                m_broadPhaseWorldAabb = _serde::__private::Some(
3152                                    match __A::next_value::<hkAabb>(&mut __map) {
3153                                        _serde::__private::Ok(__val) => __val,
3154                                        _serde::__private::Err(__err) => {
3155                                            return _serde::__private::Err(__err);
3156                                        }
3157                                    },
3158                                );
3159                            }
3160                            __Field::m_useKdTree => {
3161                                #[cfg(
3162                                    any(feature = "strict", feature = "ignore_duplicates")
3163                                )]
3164                                if _serde::__private::Option::is_some(&m_useKdTree) {
3165                                    #[cfg(feature = "ignore_duplicates")]
3166                                    {
3167                                        __A::skip_value(&mut __map)?;
3168                                        continue;
3169                                    }
3170                                    #[cfg(feature = "strict")]
3171                                    return _serde::__private::Err(
3172                                        <__A::Error as _serde::de::Error>::duplicate_field(
3173                                            "useKdTree",
3174                                        ),
3175                                    );
3176                                }
3177                                m_useKdTree = _serde::__private::Some(
3178                                    match __A::next_value::<bool>(&mut __map) {
3179                                        _serde::__private::Ok(__val) => __val,
3180                                        _serde::__private::Err(__err) => {
3181                                            return _serde::__private::Err(__err);
3182                                        }
3183                                    },
3184                                );
3185                            }
3186                            __Field::m_useMultipleTree => {
3187                                #[cfg(
3188                                    any(feature = "strict", feature = "ignore_duplicates")
3189                                )]
3190                                if _serde::__private::Option::is_some(&m_useMultipleTree) {
3191                                    #[cfg(feature = "ignore_duplicates")]
3192                                    {
3193                                        __A::skip_value(&mut __map)?;
3194                                        continue;
3195                                    }
3196                                    #[cfg(feature = "strict")]
3197                                    return _serde::__private::Err(
3198                                        <__A::Error as _serde::de::Error>::duplicate_field(
3199                                            "useMultipleTree",
3200                                        ),
3201                                    );
3202                                }
3203                                m_useMultipleTree = _serde::__private::Some(
3204                                    match __A::next_value::<bool>(&mut __map) {
3205                                        _serde::__private::Ok(__val) => __val,
3206                                        _serde::__private::Err(__err) => {
3207                                            return _serde::__private::Err(__err);
3208                                        }
3209                                    },
3210                                );
3211                            }
3212                            __Field::m_treeUpdateType => {
3213                                #[cfg(
3214                                    any(feature = "strict", feature = "ignore_duplicates")
3215                                )]
3216                                if _serde::__private::Option::is_some(&m_treeUpdateType) {
3217                                    #[cfg(feature = "ignore_duplicates")]
3218                                    {
3219                                        __A::skip_value(&mut __map)?;
3220                                        continue;
3221                                    }
3222                                    #[cfg(feature = "strict")]
3223                                    return _serde::__private::Err(
3224                                        <__A::Error as _serde::de::Error>::duplicate_field(
3225                                            "treeUpdateType",
3226                                        ),
3227                                    );
3228                                }
3229                                m_treeUpdateType = _serde::__private::Some(
3230                                    match __A::next_value::<TreeUpdateType>(&mut __map) {
3231                                        _serde::__private::Ok(__val) => __val,
3232                                        _serde::__private::Err(__err) => {
3233                                            return _serde::__private::Err(__err);
3234                                        }
3235                                    },
3236                                );
3237                            }
3238                            __Field::m_autoUpdateKdTree => {
3239                                #[cfg(
3240                                    any(feature = "strict", feature = "ignore_duplicates")
3241                                )]
3242                                if _serde::__private::Option::is_some(&m_autoUpdateKdTree) {
3243                                    #[cfg(feature = "ignore_duplicates")]
3244                                    {
3245                                        __A::skip_value(&mut __map)?;
3246                                        continue;
3247                                    }
3248                                    #[cfg(feature = "strict")]
3249                                    return _serde::__private::Err(
3250                                        <__A::Error as _serde::de::Error>::duplicate_field(
3251                                            "autoUpdateKdTree",
3252                                        ),
3253                                    );
3254                                }
3255                                m_autoUpdateKdTree = _serde::__private::Some(
3256                                    match __A::next_value::<bool>(&mut __map) {
3257                                        _serde::__private::Ok(__val) => __val,
3258                                        _serde::__private::Err(__err) => {
3259                                            return _serde::__private::Err(__err);
3260                                        }
3261                                    },
3262                                );
3263                            }
3264                            __Field::m_collisionTolerance => {
3265                                #[cfg(
3266                                    any(feature = "strict", feature = "ignore_duplicates")
3267                                )]
3268                                if _serde::__private::Option::is_some(
3269                                    &m_collisionTolerance,
3270                                ) {
3271                                    #[cfg(feature = "ignore_duplicates")]
3272                                    {
3273                                        __A::skip_value(&mut __map)?;
3274                                        continue;
3275                                    }
3276                                    #[cfg(feature = "strict")]
3277                                    return _serde::__private::Err(
3278                                        <__A::Error as _serde::de::Error>::duplicate_field(
3279                                            "collisionTolerance",
3280                                        ),
3281                                    );
3282                                }
3283                                m_collisionTolerance = _serde::__private::Some(
3284                                    match __A::next_value::<f32>(&mut __map) {
3285                                        _serde::__private::Ok(__val) => __val,
3286                                        _serde::__private::Err(__err) => {
3287                                            return _serde::__private::Err(__err);
3288                                        }
3289                                    },
3290                                );
3291                            }
3292                            __Field::m_collisionFilter => {
3293                                #[cfg(
3294                                    any(feature = "strict", feature = "ignore_duplicates")
3295                                )]
3296                                if _serde::__private::Option::is_some(&m_collisionFilter) {
3297                                    #[cfg(feature = "ignore_duplicates")]
3298                                    {
3299                                        __A::skip_value(&mut __map)?;
3300                                        continue;
3301                                    }
3302                                    #[cfg(feature = "strict")]
3303                                    return _serde::__private::Err(
3304                                        <__A::Error as _serde::de::Error>::duplicate_field(
3305                                            "collisionFilter",
3306                                        ),
3307                                    );
3308                                }
3309                                m_collisionFilter = _serde::__private::Some(
3310                                    match __A::next_value::<Pointer>(&mut __map) {
3311                                        _serde::__private::Ok(__val) => __val,
3312                                        _serde::__private::Err(__err) => {
3313                                            return _serde::__private::Err(__err);
3314                                        }
3315                                    },
3316                                );
3317                            }
3318                            __Field::m_convexListFilter => {
3319                                #[cfg(
3320                                    any(feature = "strict", feature = "ignore_duplicates")
3321                                )]
3322                                if _serde::__private::Option::is_some(&m_convexListFilter) {
3323                                    #[cfg(feature = "ignore_duplicates")]
3324                                    {
3325                                        __A::skip_value(&mut __map)?;
3326                                        continue;
3327                                    }
3328                                    #[cfg(feature = "strict")]
3329                                    return _serde::__private::Err(
3330                                        <__A::Error as _serde::de::Error>::duplicate_field(
3331                                            "convexListFilter",
3332                                        ),
3333                                    );
3334                                }
3335                                m_convexListFilter = _serde::__private::Some(
3336                                    match __A::next_value::<Pointer>(&mut __map) {
3337                                        _serde::__private::Ok(__val) => __val,
3338                                        _serde::__private::Err(__err) => {
3339                                            return _serde::__private::Err(__err);
3340                                        }
3341                                    },
3342                                );
3343                            }
3344                            __Field::m_expectedMaxLinearVelocity => {
3345                                #[cfg(
3346                                    any(feature = "strict", feature = "ignore_duplicates")
3347                                )]
3348                                if _serde::__private::Option::is_some(
3349                                    &m_expectedMaxLinearVelocity,
3350                                ) {
3351                                    #[cfg(feature = "ignore_duplicates")]
3352                                    {
3353                                        __A::skip_value(&mut __map)?;
3354                                        continue;
3355                                    }
3356                                    #[cfg(feature = "strict")]
3357                                    return _serde::__private::Err(
3358                                        <__A::Error as _serde::de::Error>::duplicate_field(
3359                                            "expectedMaxLinearVelocity",
3360                                        ),
3361                                    );
3362                                }
3363                                m_expectedMaxLinearVelocity = _serde::__private::Some(
3364                                    match __A::next_value::<f32>(&mut __map) {
3365                                        _serde::__private::Ok(__val) => __val,
3366                                        _serde::__private::Err(__err) => {
3367                                            return _serde::__private::Err(__err);
3368                                        }
3369                                    },
3370                                );
3371                            }
3372                            __Field::m_sizeOfToiEventQueue => {
3373                                #[cfg(
3374                                    any(feature = "strict", feature = "ignore_duplicates")
3375                                )]
3376                                if _serde::__private::Option::is_some(
3377                                    &m_sizeOfToiEventQueue,
3378                                ) {
3379                                    #[cfg(feature = "ignore_duplicates")]
3380                                    {
3381                                        __A::skip_value(&mut __map)?;
3382                                        continue;
3383                                    }
3384                                    #[cfg(feature = "strict")]
3385                                    return _serde::__private::Err(
3386                                        <__A::Error as _serde::de::Error>::duplicate_field(
3387                                            "sizeOfToiEventQueue",
3388                                        ),
3389                                    );
3390                                }
3391                                m_sizeOfToiEventQueue = _serde::__private::Some(
3392                                    match __A::next_value::<i32>(&mut __map) {
3393                                        _serde::__private::Ok(__val) => __val,
3394                                        _serde::__private::Err(__err) => {
3395                                            return _serde::__private::Err(__err);
3396                                        }
3397                                    },
3398                                );
3399                            }
3400                            __Field::m_expectedMinPsiDeltaTime => {
3401                                #[cfg(
3402                                    any(feature = "strict", feature = "ignore_duplicates")
3403                                )]
3404                                if _serde::__private::Option::is_some(
3405                                    &m_expectedMinPsiDeltaTime,
3406                                ) {
3407                                    #[cfg(feature = "ignore_duplicates")]
3408                                    {
3409                                        __A::skip_value(&mut __map)?;
3410                                        continue;
3411                                    }
3412                                    #[cfg(feature = "strict")]
3413                                    return _serde::__private::Err(
3414                                        <__A::Error as _serde::de::Error>::duplicate_field(
3415                                            "expectedMinPsiDeltaTime",
3416                                        ),
3417                                    );
3418                                }
3419                                m_expectedMinPsiDeltaTime = _serde::__private::Some(
3420                                    match __A::next_value::<f32>(&mut __map) {
3421                                        _serde::__private::Ok(__val) => __val,
3422                                        _serde::__private::Err(__err) => {
3423                                            return _serde::__private::Err(__err);
3424                                        }
3425                                    },
3426                                );
3427                            }
3428                            __Field::m_memoryWatchDog => {
3429                                #[cfg(
3430                                    any(feature = "strict", feature = "ignore_duplicates")
3431                                )]
3432                                if _serde::__private::Option::is_some(&m_memoryWatchDog) {
3433                                    #[cfg(feature = "ignore_duplicates")]
3434                                    {
3435                                        __A::skip_value(&mut __map)?;
3436                                        continue;
3437                                    }
3438                                    #[cfg(feature = "strict")]
3439                                    return _serde::__private::Err(
3440                                        <__A::Error as _serde::de::Error>::duplicate_field(
3441                                            "memoryWatchDog",
3442                                        ),
3443                                    );
3444                                }
3445                                m_memoryWatchDog = _serde::__private::Some(
3446                                    match __A::next_value::<Pointer>(&mut __map) {
3447                                        _serde::__private::Ok(__val) => __val,
3448                                        _serde::__private::Err(__err) => {
3449                                            return _serde::__private::Err(__err);
3450                                        }
3451                                    },
3452                                );
3453                            }
3454                            __Field::m_broadPhaseNumMarkers => {
3455                                #[cfg(
3456                                    any(feature = "strict", feature = "ignore_duplicates")
3457                                )]
3458                                if _serde::__private::Option::is_some(
3459                                    &m_broadPhaseNumMarkers,
3460                                ) {
3461                                    #[cfg(feature = "ignore_duplicates")]
3462                                    {
3463                                        __A::skip_value(&mut __map)?;
3464                                        continue;
3465                                    }
3466                                    #[cfg(feature = "strict")]
3467                                    return _serde::__private::Err(
3468                                        <__A::Error as _serde::de::Error>::duplicate_field(
3469                                            "broadPhaseNumMarkers",
3470                                        ),
3471                                    );
3472                                }
3473                                m_broadPhaseNumMarkers = _serde::__private::Some(
3474                                    match __A::next_value::<i32>(&mut __map) {
3475                                        _serde::__private::Ok(__val) => __val,
3476                                        _serde::__private::Err(__err) => {
3477                                            return _serde::__private::Err(__err);
3478                                        }
3479                                    },
3480                                );
3481                            }
3482                            __Field::m_contactPointGeneration => {
3483                                #[cfg(
3484                                    any(feature = "strict", feature = "ignore_duplicates")
3485                                )]
3486                                if _serde::__private::Option::is_some(
3487                                    &m_contactPointGeneration,
3488                                ) {
3489                                    #[cfg(feature = "ignore_duplicates")]
3490                                    {
3491                                        __A::skip_value(&mut __map)?;
3492                                        continue;
3493                                    }
3494                                    #[cfg(feature = "strict")]
3495                                    return _serde::__private::Err(
3496                                        <__A::Error as _serde::de::Error>::duplicate_field(
3497                                            "contactPointGeneration",
3498                                        ),
3499                                    );
3500                                }
3501                                m_contactPointGeneration = _serde::__private::Some(
3502                                    match __A::next_value::<
3503                                        ContactPointGeneration,
3504                                    >(&mut __map) {
3505                                        _serde::__private::Ok(__val) => __val,
3506                                        _serde::__private::Err(__err) => {
3507                                            return _serde::__private::Err(__err);
3508                                        }
3509                                    },
3510                                );
3511                            }
3512                            __Field::m_allowToSkipConfirmedCallbacks => {
3513                                #[cfg(
3514                                    any(feature = "strict", feature = "ignore_duplicates")
3515                                )]
3516                                if _serde::__private::Option::is_some(
3517                                    &m_allowToSkipConfirmedCallbacks,
3518                                ) {
3519                                    #[cfg(feature = "ignore_duplicates")]
3520                                    {
3521                                        __A::skip_value(&mut __map)?;
3522                                        continue;
3523                                    }
3524                                    #[cfg(feature = "strict")]
3525                                    return _serde::__private::Err(
3526                                        <__A::Error as _serde::de::Error>::duplicate_field(
3527                                            "allowToSkipConfirmedCallbacks",
3528                                        ),
3529                                    );
3530                                }
3531                                m_allowToSkipConfirmedCallbacks = _serde::__private::Some(
3532                                    match __A::next_value::<bool>(&mut __map) {
3533                                        _serde::__private::Ok(__val) => __val,
3534                                        _serde::__private::Err(__err) => {
3535                                            return _serde::__private::Err(__err);
3536                                        }
3537                                    },
3538                                );
3539                            }
3540                            __Field::m_useHybridBroadphase => {
3541                                #[cfg(
3542                                    any(feature = "strict", feature = "ignore_duplicates")
3543                                )]
3544                                if _serde::__private::Option::is_some(
3545                                    &m_useHybridBroadphase,
3546                                ) {
3547                                    #[cfg(feature = "ignore_duplicates")]
3548                                    {
3549                                        __A::skip_value(&mut __map)?;
3550                                        continue;
3551                                    }
3552                                    #[cfg(feature = "strict")]
3553                                    return _serde::__private::Err(
3554                                        <__A::Error as _serde::de::Error>::duplicate_field(
3555                                            "useHybridBroadphase",
3556                                        ),
3557                                    );
3558                                }
3559                                m_useHybridBroadphase = _serde::__private::Some(
3560                                    match __A::next_value::<bool>(&mut __map) {
3561                                        _serde::__private::Ok(__val) => __val,
3562                                        _serde::__private::Err(__err) => {
3563                                            return _serde::__private::Err(__err);
3564                                        }
3565                                    },
3566                                );
3567                            }
3568                            __Field::m_solverTau => {
3569                                #[cfg(
3570                                    any(feature = "strict", feature = "ignore_duplicates")
3571                                )]
3572                                if _serde::__private::Option::is_some(&m_solverTau) {
3573                                    #[cfg(feature = "ignore_duplicates")]
3574                                    {
3575                                        __A::skip_value(&mut __map)?;
3576                                        continue;
3577                                    }
3578                                    #[cfg(feature = "strict")]
3579                                    return _serde::__private::Err(
3580                                        <__A::Error as _serde::de::Error>::duplicate_field(
3581                                            "solverTau",
3582                                        ),
3583                                    );
3584                                }
3585                                m_solverTau = _serde::__private::Some(
3586                                    match __A::next_value::<f32>(&mut __map) {
3587                                        _serde::__private::Ok(__val) => __val,
3588                                        _serde::__private::Err(__err) => {
3589                                            return _serde::__private::Err(__err);
3590                                        }
3591                                    },
3592                                );
3593                            }
3594                            __Field::m_solverDamp => {
3595                                #[cfg(
3596                                    any(feature = "strict", feature = "ignore_duplicates")
3597                                )]
3598                                if _serde::__private::Option::is_some(&m_solverDamp) {
3599                                    #[cfg(feature = "ignore_duplicates")]
3600                                    {
3601                                        __A::skip_value(&mut __map)?;
3602                                        continue;
3603                                    }
3604                                    #[cfg(feature = "strict")]
3605                                    return _serde::__private::Err(
3606                                        <__A::Error as _serde::de::Error>::duplicate_field(
3607                                            "solverDamp",
3608                                        ),
3609                                    );
3610                                }
3611                                m_solverDamp = _serde::__private::Some(
3612                                    match __A::next_value::<f32>(&mut __map) {
3613                                        _serde::__private::Ok(__val) => __val,
3614                                        _serde::__private::Err(__err) => {
3615                                            return _serde::__private::Err(__err);
3616                                        }
3617                                    },
3618                                );
3619                            }
3620                            __Field::m_solverIterations => {
3621                                #[cfg(
3622                                    any(feature = "strict", feature = "ignore_duplicates")
3623                                )]
3624                                if _serde::__private::Option::is_some(&m_solverIterations) {
3625                                    #[cfg(feature = "ignore_duplicates")]
3626                                    {
3627                                        __A::skip_value(&mut __map)?;
3628                                        continue;
3629                                    }
3630                                    #[cfg(feature = "strict")]
3631                                    return _serde::__private::Err(
3632                                        <__A::Error as _serde::de::Error>::duplicate_field(
3633                                            "solverIterations",
3634                                        ),
3635                                    );
3636                                }
3637                                m_solverIterations = _serde::__private::Some(
3638                                    match __A::next_value::<i32>(&mut __map) {
3639                                        _serde::__private::Ok(__val) => __val,
3640                                        _serde::__private::Err(__err) => {
3641                                            return _serde::__private::Err(__err);
3642                                        }
3643                                    },
3644                                );
3645                            }
3646                            __Field::m_solverMicrosteps => {
3647                                #[cfg(
3648                                    any(feature = "strict", feature = "ignore_duplicates")
3649                                )]
3650                                if _serde::__private::Option::is_some(&m_solverMicrosteps) {
3651                                    #[cfg(feature = "ignore_duplicates")]
3652                                    {
3653                                        __A::skip_value(&mut __map)?;
3654                                        continue;
3655                                    }
3656                                    #[cfg(feature = "strict")]
3657                                    return _serde::__private::Err(
3658                                        <__A::Error as _serde::de::Error>::duplicate_field(
3659                                            "solverMicrosteps",
3660                                        ),
3661                                    );
3662                                }
3663                                m_solverMicrosteps = _serde::__private::Some(
3664                                    match __A::next_value::<i32>(&mut __map) {
3665                                        _serde::__private::Ok(__val) => __val,
3666                                        _serde::__private::Err(__err) => {
3667                                            return _serde::__private::Err(__err);
3668                                        }
3669                                    },
3670                                );
3671                            }
3672                            __Field::m_maxConstraintViolation => {
3673                                #[cfg(
3674                                    any(feature = "strict", feature = "ignore_duplicates")
3675                                )]
3676                                if _serde::__private::Option::is_some(
3677                                    &m_maxConstraintViolation,
3678                                ) {
3679                                    #[cfg(feature = "ignore_duplicates")]
3680                                    {
3681                                        __A::skip_value(&mut __map)?;
3682                                        continue;
3683                                    }
3684                                    #[cfg(feature = "strict")]
3685                                    return _serde::__private::Err(
3686                                        <__A::Error as _serde::de::Error>::duplicate_field(
3687                                            "maxConstraintViolation",
3688                                        ),
3689                                    );
3690                                }
3691                                m_maxConstraintViolation = _serde::__private::Some(
3692                                    match __A::next_value::<f32>(&mut __map) {
3693                                        _serde::__private::Ok(__val) => __val,
3694                                        _serde::__private::Err(__err) => {
3695                                            return _serde::__private::Err(__err);
3696                                        }
3697                                    },
3698                                );
3699                            }
3700                            __Field::m_forceCoherentConstraintOrderingInSolver => {
3701                                #[cfg(
3702                                    any(feature = "strict", feature = "ignore_duplicates")
3703                                )]
3704                                if _serde::__private::Option::is_some(
3705                                    &m_forceCoherentConstraintOrderingInSolver,
3706                                ) {
3707                                    #[cfg(feature = "ignore_duplicates")]
3708                                    {
3709                                        __A::skip_value(&mut __map)?;
3710                                        continue;
3711                                    }
3712                                    #[cfg(feature = "strict")]
3713                                    return _serde::__private::Err(
3714                                        <__A::Error as _serde::de::Error>::duplicate_field(
3715                                            "forceCoherentConstraintOrderingInSolver",
3716                                        ),
3717                                    );
3718                                }
3719                                m_forceCoherentConstraintOrderingInSolver = _serde::__private::Some(
3720                                    match __A::next_value::<bool>(&mut __map) {
3721                                        _serde::__private::Ok(__val) => __val,
3722                                        _serde::__private::Err(__err) => {
3723                                            return _serde::__private::Err(__err);
3724                                        }
3725                                    },
3726                                );
3727                            }
3728                            __Field::m_snapCollisionToConvexEdgeThreshold => {
3729                                #[cfg(
3730                                    any(feature = "strict", feature = "ignore_duplicates")
3731                                )]
3732                                if _serde::__private::Option::is_some(
3733                                    &m_snapCollisionToConvexEdgeThreshold,
3734                                ) {
3735                                    #[cfg(feature = "ignore_duplicates")]
3736                                    {
3737                                        __A::skip_value(&mut __map)?;
3738                                        continue;
3739                                    }
3740                                    #[cfg(feature = "strict")]
3741                                    return _serde::__private::Err(
3742                                        <__A::Error as _serde::de::Error>::duplicate_field(
3743                                            "snapCollisionToConvexEdgeThreshold",
3744                                        ),
3745                                    );
3746                                }
3747                                m_snapCollisionToConvexEdgeThreshold = _serde::__private::Some(
3748                                    match __A::next_value::<f32>(&mut __map) {
3749                                        _serde::__private::Ok(__val) => __val,
3750                                        _serde::__private::Err(__err) => {
3751                                            return _serde::__private::Err(__err);
3752                                        }
3753                                    },
3754                                );
3755                            }
3756                            __Field::m_snapCollisionToConcaveEdgeThreshold => {
3757                                #[cfg(
3758                                    any(feature = "strict", feature = "ignore_duplicates")
3759                                )]
3760                                if _serde::__private::Option::is_some(
3761                                    &m_snapCollisionToConcaveEdgeThreshold,
3762                                ) {
3763                                    #[cfg(feature = "ignore_duplicates")]
3764                                    {
3765                                        __A::skip_value(&mut __map)?;
3766                                        continue;
3767                                    }
3768                                    #[cfg(feature = "strict")]
3769                                    return _serde::__private::Err(
3770                                        <__A::Error as _serde::de::Error>::duplicate_field(
3771                                            "snapCollisionToConcaveEdgeThreshold",
3772                                        ),
3773                                    );
3774                                }
3775                                m_snapCollisionToConcaveEdgeThreshold = _serde::__private::Some(
3776                                    match __A::next_value::<f32>(&mut __map) {
3777                                        _serde::__private::Ok(__val) => __val,
3778                                        _serde::__private::Err(__err) => {
3779                                            return _serde::__private::Err(__err);
3780                                        }
3781                                    },
3782                                );
3783                            }
3784                            __Field::m_enableToiWeldRejection => {
3785                                #[cfg(
3786                                    any(feature = "strict", feature = "ignore_duplicates")
3787                                )]
3788                                if _serde::__private::Option::is_some(
3789                                    &m_enableToiWeldRejection,
3790                                ) {
3791                                    #[cfg(feature = "ignore_duplicates")]
3792                                    {
3793                                        __A::skip_value(&mut __map)?;
3794                                        continue;
3795                                    }
3796                                    #[cfg(feature = "strict")]
3797                                    return _serde::__private::Err(
3798                                        <__A::Error as _serde::de::Error>::duplicate_field(
3799                                            "enableToiWeldRejection",
3800                                        ),
3801                                    );
3802                                }
3803                                m_enableToiWeldRejection = _serde::__private::Some(
3804                                    match __A::next_value::<bool>(&mut __map) {
3805                                        _serde::__private::Ok(__val) => __val,
3806                                        _serde::__private::Err(__err) => {
3807                                            return _serde::__private::Err(__err);
3808                                        }
3809                                    },
3810                                );
3811                            }
3812                            __Field::m_enableDeprecatedWelding => {
3813                                #[cfg(
3814                                    any(feature = "strict", feature = "ignore_duplicates")
3815                                )]
3816                                if _serde::__private::Option::is_some(
3817                                    &m_enableDeprecatedWelding,
3818                                ) {
3819                                    #[cfg(feature = "ignore_duplicates")]
3820                                    {
3821                                        __A::skip_value(&mut __map)?;
3822                                        continue;
3823                                    }
3824                                    #[cfg(feature = "strict")]
3825                                    return _serde::__private::Err(
3826                                        <__A::Error as _serde::de::Error>::duplicate_field(
3827                                            "enableDeprecatedWelding",
3828                                        ),
3829                                    );
3830                                }
3831                                m_enableDeprecatedWelding = _serde::__private::Some(
3832                                    match __A::next_value::<bool>(&mut __map) {
3833                                        _serde::__private::Ok(__val) => __val,
3834                                        _serde::__private::Err(__err) => {
3835                                            return _serde::__private::Err(__err);
3836                                        }
3837                                    },
3838                                );
3839                            }
3840                            __Field::m_iterativeLinearCastEarlyOutDistance => {
3841                                #[cfg(
3842                                    any(feature = "strict", feature = "ignore_duplicates")
3843                                )]
3844                                if _serde::__private::Option::is_some(
3845                                    &m_iterativeLinearCastEarlyOutDistance,
3846                                ) {
3847                                    #[cfg(feature = "ignore_duplicates")]
3848                                    {
3849                                        __A::skip_value(&mut __map)?;
3850                                        continue;
3851                                    }
3852                                    #[cfg(feature = "strict")]
3853                                    return _serde::__private::Err(
3854                                        <__A::Error as _serde::de::Error>::duplicate_field(
3855                                            "iterativeLinearCastEarlyOutDistance",
3856                                        ),
3857                                    );
3858                                }
3859                                m_iterativeLinearCastEarlyOutDistance = _serde::__private::Some(
3860                                    match __A::next_value::<f32>(&mut __map) {
3861                                        _serde::__private::Ok(__val) => __val,
3862                                        _serde::__private::Err(__err) => {
3863                                            return _serde::__private::Err(__err);
3864                                        }
3865                                    },
3866                                );
3867                            }
3868                            __Field::m_iterativeLinearCastMaxIterations => {
3869                                #[cfg(
3870                                    any(feature = "strict", feature = "ignore_duplicates")
3871                                )]
3872                                if _serde::__private::Option::is_some(
3873                                    &m_iterativeLinearCastMaxIterations,
3874                                ) {
3875                                    #[cfg(feature = "ignore_duplicates")]
3876                                    {
3877                                        __A::skip_value(&mut __map)?;
3878                                        continue;
3879                                    }
3880                                    #[cfg(feature = "strict")]
3881                                    return _serde::__private::Err(
3882                                        <__A::Error as _serde::de::Error>::duplicate_field(
3883                                            "iterativeLinearCastMaxIterations",
3884                                        ),
3885                                    );
3886                                }
3887                                m_iterativeLinearCastMaxIterations = _serde::__private::Some(
3888                                    match __A::next_value::<i32>(&mut __map) {
3889                                        _serde::__private::Ok(__val) => __val,
3890                                        _serde::__private::Err(__err) => {
3891                                            return _serde::__private::Err(__err);
3892                                        }
3893                                    },
3894                                );
3895                            }
3896                            __Field::m_deactivationNumInactiveFramesSelectFlag0 => {
3897                                #[cfg(
3898                                    any(feature = "strict", feature = "ignore_duplicates")
3899                                )]
3900                                if _serde::__private::Option::is_some(
3901                                    &m_deactivationNumInactiveFramesSelectFlag0,
3902                                ) {
3903                                    #[cfg(feature = "ignore_duplicates")]
3904                                    {
3905                                        __A::skip_value(&mut __map)?;
3906                                        continue;
3907                                    }
3908                                    #[cfg(feature = "strict")]
3909                                    return _serde::__private::Err(
3910                                        <__A::Error as _serde::de::Error>::duplicate_field(
3911                                            "deactivationNumInactiveFramesSelectFlag0",
3912                                        ),
3913                                    );
3914                                }
3915                                m_deactivationNumInactiveFramesSelectFlag0 = _serde::__private::Some(
3916                                    match __A::next_value::<u8>(&mut __map) {
3917                                        _serde::__private::Ok(__val) => __val,
3918                                        _serde::__private::Err(__err) => {
3919                                            return _serde::__private::Err(__err);
3920                                        }
3921                                    },
3922                                );
3923                            }
3924                            __Field::m_deactivationNumInactiveFramesSelectFlag1 => {
3925                                #[cfg(
3926                                    any(feature = "strict", feature = "ignore_duplicates")
3927                                )]
3928                                if _serde::__private::Option::is_some(
3929                                    &m_deactivationNumInactiveFramesSelectFlag1,
3930                                ) {
3931                                    #[cfg(feature = "ignore_duplicates")]
3932                                    {
3933                                        __A::skip_value(&mut __map)?;
3934                                        continue;
3935                                    }
3936                                    #[cfg(feature = "strict")]
3937                                    return _serde::__private::Err(
3938                                        <__A::Error as _serde::de::Error>::duplicate_field(
3939                                            "deactivationNumInactiveFramesSelectFlag1",
3940                                        ),
3941                                    );
3942                                }
3943                                m_deactivationNumInactiveFramesSelectFlag1 = _serde::__private::Some(
3944                                    match __A::next_value::<u8>(&mut __map) {
3945                                        _serde::__private::Ok(__val) => __val,
3946                                        _serde::__private::Err(__err) => {
3947                                            return _serde::__private::Err(__err);
3948                                        }
3949                                    },
3950                                );
3951                            }
3952                            __Field::m_deactivationIntegrateCounter => {
3953                                #[cfg(
3954                                    any(feature = "strict", feature = "ignore_duplicates")
3955                                )]
3956                                if _serde::__private::Option::is_some(
3957                                    &m_deactivationIntegrateCounter,
3958                                ) {
3959                                    #[cfg(feature = "ignore_duplicates")]
3960                                    {
3961                                        __A::skip_value(&mut __map)?;
3962                                        continue;
3963                                    }
3964                                    #[cfg(feature = "strict")]
3965                                    return _serde::__private::Err(
3966                                        <__A::Error as _serde::de::Error>::duplicate_field(
3967                                            "deactivationIntegrateCounter",
3968                                        ),
3969                                    );
3970                                }
3971                                m_deactivationIntegrateCounter = _serde::__private::Some(
3972                                    match __A::next_value::<u8>(&mut __map) {
3973                                        _serde::__private::Ok(__val) => __val,
3974                                        _serde::__private::Err(__err) => {
3975                                            return _serde::__private::Err(__err);
3976                                        }
3977                                    },
3978                                );
3979                            }
3980                            __Field::m_shouldActivateOnRigidBodyTransformChange => {
3981                                #[cfg(
3982                                    any(feature = "strict", feature = "ignore_duplicates")
3983                                )]
3984                                if _serde::__private::Option::is_some(
3985                                    &m_shouldActivateOnRigidBodyTransformChange,
3986                                ) {
3987                                    #[cfg(feature = "ignore_duplicates")]
3988                                    {
3989                                        __A::skip_value(&mut __map)?;
3990                                        continue;
3991                                    }
3992                                    #[cfg(feature = "strict")]
3993                                    return _serde::__private::Err(
3994                                        <__A::Error as _serde::de::Error>::duplicate_field(
3995                                            "shouldActivateOnRigidBodyTransformChange",
3996                                        ),
3997                                    );
3998                                }
3999                                m_shouldActivateOnRigidBodyTransformChange = _serde::__private::Some(
4000                                    match __A::next_value::<bool>(&mut __map) {
4001                                        _serde::__private::Ok(__val) => __val,
4002                                        _serde::__private::Err(__err) => {
4003                                            return _serde::__private::Err(__err);
4004                                        }
4005                                    },
4006                                );
4007                            }
4008                            __Field::m_deactivationReferenceDistance => {
4009                                #[cfg(
4010                                    any(feature = "strict", feature = "ignore_duplicates")
4011                                )]
4012                                if _serde::__private::Option::is_some(
4013                                    &m_deactivationReferenceDistance,
4014                                ) {
4015                                    #[cfg(feature = "ignore_duplicates")]
4016                                    {
4017                                        __A::skip_value(&mut __map)?;
4018                                        continue;
4019                                    }
4020                                    #[cfg(feature = "strict")]
4021                                    return _serde::__private::Err(
4022                                        <__A::Error as _serde::de::Error>::duplicate_field(
4023                                            "deactivationReferenceDistance",
4024                                        ),
4025                                    );
4026                                }
4027                                m_deactivationReferenceDistance = _serde::__private::Some(
4028                                    match __A::next_value::<f32>(&mut __map) {
4029                                        _serde::__private::Ok(__val) => __val,
4030                                        _serde::__private::Err(__err) => {
4031                                            return _serde::__private::Err(__err);
4032                                        }
4033                                    },
4034                                );
4035                            }
4036                            __Field::m_toiCollisionResponseRotateNormal => {
4037                                #[cfg(
4038                                    any(feature = "strict", feature = "ignore_duplicates")
4039                                )]
4040                                if _serde::__private::Option::is_some(
4041                                    &m_toiCollisionResponseRotateNormal,
4042                                ) {
4043                                    #[cfg(feature = "ignore_duplicates")]
4044                                    {
4045                                        __A::skip_value(&mut __map)?;
4046                                        continue;
4047                                    }
4048                                    #[cfg(feature = "strict")]
4049                                    return _serde::__private::Err(
4050                                        <__A::Error as _serde::de::Error>::duplicate_field(
4051                                            "toiCollisionResponseRotateNormal",
4052                                        ),
4053                                    );
4054                                }
4055                                m_toiCollisionResponseRotateNormal = _serde::__private::Some(
4056                                    match __A::next_value::<f32>(&mut __map) {
4057                                        _serde::__private::Ok(__val) => __val,
4058                                        _serde::__private::Err(__err) => {
4059                                            return _serde::__private::Err(__err);
4060                                        }
4061                                    },
4062                                );
4063                            }
4064                            __Field::m_maxSectorsPerMidphaseCollideTask => {
4065                                #[cfg(
4066                                    any(feature = "strict", feature = "ignore_duplicates")
4067                                )]
4068                                if _serde::__private::Option::is_some(
4069                                    &m_maxSectorsPerMidphaseCollideTask,
4070                                ) {
4071                                    #[cfg(feature = "ignore_duplicates")]
4072                                    {
4073                                        __A::skip_value(&mut __map)?;
4074                                        continue;
4075                                    }
4076                                    #[cfg(feature = "strict")]
4077                                    return _serde::__private::Err(
4078                                        <__A::Error as _serde::de::Error>::duplicate_field(
4079                                            "maxSectorsPerMidphaseCollideTask",
4080                                        ),
4081                                    );
4082                                }
4083                                m_maxSectorsPerMidphaseCollideTask = _serde::__private::Some(
4084                                    match __A::next_value::<i32>(&mut __map) {
4085                                        _serde::__private::Ok(__val) => __val,
4086                                        _serde::__private::Err(__err) => {
4087                                            return _serde::__private::Err(__err);
4088                                        }
4089                                    },
4090                                );
4091                            }
4092                            __Field::m_maxSectorsPerNarrowphaseCollideTask => {
4093                                #[cfg(
4094                                    any(feature = "strict", feature = "ignore_duplicates")
4095                                )]
4096                                if _serde::__private::Option::is_some(
4097                                    &m_maxSectorsPerNarrowphaseCollideTask,
4098                                ) {
4099                                    #[cfg(feature = "ignore_duplicates")]
4100                                    {
4101                                        __A::skip_value(&mut __map)?;
4102                                        continue;
4103                                    }
4104                                    #[cfg(feature = "strict")]
4105                                    return _serde::__private::Err(
4106                                        <__A::Error as _serde::de::Error>::duplicate_field(
4107                                            "maxSectorsPerNarrowphaseCollideTask",
4108                                        ),
4109                                    );
4110                                }
4111                                m_maxSectorsPerNarrowphaseCollideTask = _serde::__private::Some(
4112                                    match __A::next_value::<i32>(&mut __map) {
4113                                        _serde::__private::Ok(__val) => __val,
4114                                        _serde::__private::Err(__err) => {
4115                                            return _serde::__private::Err(__err);
4116                                        }
4117                                    },
4118                                );
4119                            }
4120                            __Field::m_processToisMultithreaded => {
4121                                #[cfg(
4122                                    any(feature = "strict", feature = "ignore_duplicates")
4123                                )]
4124                                if _serde::__private::Option::is_some(
4125                                    &m_processToisMultithreaded,
4126                                ) {
4127                                    #[cfg(feature = "ignore_duplicates")]
4128                                    {
4129                                        __A::skip_value(&mut __map)?;
4130                                        continue;
4131                                    }
4132                                    #[cfg(feature = "strict")]
4133                                    return _serde::__private::Err(
4134                                        <__A::Error as _serde::de::Error>::duplicate_field(
4135                                            "processToisMultithreaded",
4136                                        ),
4137                                    );
4138                                }
4139                                m_processToisMultithreaded = _serde::__private::Some(
4140                                    match __A::next_value::<bool>(&mut __map) {
4141                                        _serde::__private::Ok(__val) => __val,
4142                                        _serde::__private::Err(__err) => {
4143                                            return _serde::__private::Err(__err);
4144                                        }
4145                                    },
4146                                );
4147                            }
4148                            __Field::m_maxEntriesPerToiMidphaseCollideTask => {
4149                                #[cfg(
4150                                    any(feature = "strict", feature = "ignore_duplicates")
4151                                )]
4152                                if _serde::__private::Option::is_some(
4153                                    &m_maxEntriesPerToiMidphaseCollideTask,
4154                                ) {
4155                                    #[cfg(feature = "ignore_duplicates")]
4156                                    {
4157                                        __A::skip_value(&mut __map)?;
4158                                        continue;
4159                                    }
4160                                    #[cfg(feature = "strict")]
4161                                    return _serde::__private::Err(
4162                                        <__A::Error as _serde::de::Error>::duplicate_field(
4163                                            "maxEntriesPerToiMidphaseCollideTask",
4164                                        ),
4165                                    );
4166                                }
4167                                m_maxEntriesPerToiMidphaseCollideTask = _serde::__private::Some(
4168                                    match __A::next_value::<i32>(&mut __map) {
4169                                        _serde::__private::Ok(__val) => __val,
4170                                        _serde::__private::Err(__err) => {
4171                                            return _serde::__private::Err(__err);
4172                                        }
4173                                    },
4174                                );
4175                            }
4176                            __Field::m_maxEntriesPerToiNarrowphaseCollideTask => {
4177                                #[cfg(
4178                                    any(feature = "strict", feature = "ignore_duplicates")
4179                                )]
4180                                if _serde::__private::Option::is_some(
4181                                    &m_maxEntriesPerToiNarrowphaseCollideTask,
4182                                ) {
4183                                    #[cfg(feature = "ignore_duplicates")]
4184                                    {
4185                                        __A::skip_value(&mut __map)?;
4186                                        continue;
4187                                    }
4188                                    #[cfg(feature = "strict")]
4189                                    return _serde::__private::Err(
4190                                        <__A::Error as _serde::de::Error>::duplicate_field(
4191                                            "maxEntriesPerToiNarrowphaseCollideTask",
4192                                        ),
4193                                    );
4194                                }
4195                                m_maxEntriesPerToiNarrowphaseCollideTask = _serde::__private::Some(
4196                                    match __A::next_value::<i32>(&mut __map) {
4197                                        _serde::__private::Ok(__val) => __val,
4198                                        _serde::__private::Err(__err) => {
4199                                            return _serde::__private::Err(__err);
4200                                        }
4201                                    },
4202                                );
4203                            }
4204                            __Field::m_maxNumToiCollisionPairsSinglethreaded => {
4205                                #[cfg(
4206                                    any(feature = "strict", feature = "ignore_duplicates")
4207                                )]
4208                                if _serde::__private::Option::is_some(
4209                                    &m_maxNumToiCollisionPairsSinglethreaded,
4210                                ) {
4211                                    #[cfg(feature = "ignore_duplicates")]
4212                                    {
4213                                        __A::skip_value(&mut __map)?;
4214                                        continue;
4215                                    }
4216                                    #[cfg(feature = "strict")]
4217                                    return _serde::__private::Err(
4218                                        <__A::Error as _serde::de::Error>::duplicate_field(
4219                                            "maxNumToiCollisionPairsSinglethreaded",
4220                                        ),
4221                                    );
4222                                }
4223                                m_maxNumToiCollisionPairsSinglethreaded = _serde::__private::Some(
4224                                    match __A::next_value::<i32>(&mut __map) {
4225                                        _serde::__private::Ok(__val) => __val,
4226                                        _serde::__private::Err(__err) => {
4227                                            return _serde::__private::Err(__err);
4228                                        }
4229                                    },
4230                                );
4231                            }
4232                            __Field::m_numToisTillAllowedPenetrationSimplifiedToi => {
4233                                #[cfg(
4234                                    any(feature = "strict", feature = "ignore_duplicates")
4235                                )]
4236                                if _serde::__private::Option::is_some(
4237                                    &m_numToisTillAllowedPenetrationSimplifiedToi,
4238                                ) {
4239                                    #[cfg(feature = "ignore_duplicates")]
4240                                    {
4241                                        __A::skip_value(&mut __map)?;
4242                                        continue;
4243                                    }
4244                                    #[cfg(feature = "strict")]
4245                                    return _serde::__private::Err(
4246                                        <__A::Error as _serde::de::Error>::duplicate_field(
4247                                            "numToisTillAllowedPenetrationSimplifiedToi",
4248                                        ),
4249                                    );
4250                                }
4251                                m_numToisTillAllowedPenetrationSimplifiedToi = _serde::__private::Some(
4252                                    match __A::next_value::<f32>(&mut __map) {
4253                                        _serde::__private::Ok(__val) => __val,
4254                                        _serde::__private::Err(__err) => {
4255                                            return _serde::__private::Err(__err);
4256                                        }
4257                                    },
4258                                );
4259                            }
4260                            __Field::m_numToisTillAllowedPenetrationToi => {
4261                                #[cfg(
4262                                    any(feature = "strict", feature = "ignore_duplicates")
4263                                )]
4264                                if _serde::__private::Option::is_some(
4265                                    &m_numToisTillAllowedPenetrationToi,
4266                                ) {
4267                                    #[cfg(feature = "ignore_duplicates")]
4268                                    {
4269                                        __A::skip_value(&mut __map)?;
4270                                        continue;
4271                                    }
4272                                    #[cfg(feature = "strict")]
4273                                    return _serde::__private::Err(
4274                                        <__A::Error as _serde::de::Error>::duplicate_field(
4275                                            "numToisTillAllowedPenetrationToi",
4276                                        ),
4277                                    );
4278                                }
4279                                m_numToisTillAllowedPenetrationToi = _serde::__private::Some(
4280                                    match __A::next_value::<f32>(&mut __map) {
4281                                        _serde::__private::Ok(__val) => __val,
4282                                        _serde::__private::Err(__err) => {
4283                                            return _serde::__private::Err(__err);
4284                                        }
4285                                    },
4286                                );
4287                            }
4288                            __Field::m_numToisTillAllowedPenetrationToiHigher => {
4289                                #[cfg(
4290                                    any(feature = "strict", feature = "ignore_duplicates")
4291                                )]
4292                                if _serde::__private::Option::is_some(
4293                                    &m_numToisTillAllowedPenetrationToiHigher,
4294                                ) {
4295                                    #[cfg(feature = "ignore_duplicates")]
4296                                    {
4297                                        __A::skip_value(&mut __map)?;
4298                                        continue;
4299                                    }
4300                                    #[cfg(feature = "strict")]
4301                                    return _serde::__private::Err(
4302                                        <__A::Error as _serde::de::Error>::duplicate_field(
4303                                            "numToisTillAllowedPenetrationToiHigher",
4304                                        ),
4305                                    );
4306                                }
4307                                m_numToisTillAllowedPenetrationToiHigher = _serde::__private::Some(
4308                                    match __A::next_value::<f32>(&mut __map) {
4309                                        _serde::__private::Ok(__val) => __val,
4310                                        _serde::__private::Err(__err) => {
4311                                            return _serde::__private::Err(__err);
4312                                        }
4313                                    },
4314                                );
4315                            }
4316                            __Field::m_numToisTillAllowedPenetrationToiForced => {
4317                                #[cfg(
4318                                    any(feature = "strict", feature = "ignore_duplicates")
4319                                )]
4320                                if _serde::__private::Option::is_some(
4321                                    &m_numToisTillAllowedPenetrationToiForced,
4322                                ) {
4323                                    #[cfg(feature = "ignore_duplicates")]
4324                                    {
4325                                        __A::skip_value(&mut __map)?;
4326                                        continue;
4327                                    }
4328                                    #[cfg(feature = "strict")]
4329                                    return _serde::__private::Err(
4330                                        <__A::Error as _serde::de::Error>::duplicate_field(
4331                                            "numToisTillAllowedPenetrationToiForced",
4332                                        ),
4333                                    );
4334                                }
4335                                m_numToisTillAllowedPenetrationToiForced = _serde::__private::Some(
4336                                    match __A::next_value::<f32>(&mut __map) {
4337                                        _serde::__private::Ok(__val) => __val,
4338                                        _serde::__private::Err(__err) => {
4339                                            return _serde::__private::Err(__err);
4340                                        }
4341                                    },
4342                                );
4343                            }
4344                            __Field::m_enableDeactivation => {
4345                                #[cfg(
4346                                    any(feature = "strict", feature = "ignore_duplicates")
4347                                )]
4348                                if _serde::__private::Option::is_some(
4349                                    &m_enableDeactivation,
4350                                ) {
4351                                    #[cfg(feature = "ignore_duplicates")]
4352                                    {
4353                                        __A::skip_value(&mut __map)?;
4354                                        continue;
4355                                    }
4356                                    #[cfg(feature = "strict")]
4357                                    return _serde::__private::Err(
4358                                        <__A::Error as _serde::de::Error>::duplicate_field(
4359                                            "enableDeactivation",
4360                                        ),
4361                                    );
4362                                }
4363                                m_enableDeactivation = _serde::__private::Some(
4364                                    match __A::next_value::<bool>(&mut __map) {
4365                                        _serde::__private::Ok(__val) => __val,
4366                                        _serde::__private::Err(__err) => {
4367                                            return _serde::__private::Err(__err);
4368                                        }
4369                                    },
4370                                );
4371                            }
4372                            __Field::m_simulationType => {
4373                                #[cfg(
4374                                    any(feature = "strict", feature = "ignore_duplicates")
4375                                )]
4376                                if _serde::__private::Option::is_some(&m_simulationType) {
4377                                    #[cfg(feature = "ignore_duplicates")]
4378                                    {
4379                                        __A::skip_value(&mut __map)?;
4380                                        continue;
4381                                    }
4382                                    #[cfg(feature = "strict")]
4383                                    return _serde::__private::Err(
4384                                        <__A::Error as _serde::de::Error>::duplicate_field(
4385                                            "simulationType",
4386                                        ),
4387                                    );
4388                                }
4389                                m_simulationType = _serde::__private::Some(
4390                                    match __A::next_value::<SimulationType>(&mut __map) {
4391                                        _serde::__private::Ok(__val) => __val,
4392                                        _serde::__private::Err(__err) => {
4393                                            return _serde::__private::Err(__err);
4394                                        }
4395                                    },
4396                                );
4397                            }
4398                            __Field::m_enableSimulationIslands => {
4399                                #[cfg(
4400                                    any(feature = "strict", feature = "ignore_duplicates")
4401                                )]
4402                                if _serde::__private::Option::is_some(
4403                                    &m_enableSimulationIslands,
4404                                ) {
4405                                    #[cfg(feature = "ignore_duplicates")]
4406                                    {
4407                                        __A::skip_value(&mut __map)?;
4408                                        continue;
4409                                    }
4410                                    #[cfg(feature = "strict")]
4411                                    return _serde::__private::Err(
4412                                        <__A::Error as _serde::de::Error>::duplicate_field(
4413                                            "enableSimulationIslands",
4414                                        ),
4415                                    );
4416                                }
4417                                m_enableSimulationIslands = _serde::__private::Some(
4418                                    match __A::next_value::<bool>(&mut __map) {
4419                                        _serde::__private::Ok(__val) => __val,
4420                                        _serde::__private::Err(__err) => {
4421                                            return _serde::__private::Err(__err);
4422                                        }
4423                                    },
4424                                );
4425                            }
4426                            __Field::m_minDesiredIslandSize => {
4427                                #[cfg(
4428                                    any(feature = "strict", feature = "ignore_duplicates")
4429                                )]
4430                                if _serde::__private::Option::is_some(
4431                                    &m_minDesiredIslandSize,
4432                                ) {
4433                                    #[cfg(feature = "ignore_duplicates")]
4434                                    {
4435                                        __A::skip_value(&mut __map)?;
4436                                        continue;
4437                                    }
4438                                    #[cfg(feature = "strict")]
4439                                    return _serde::__private::Err(
4440                                        <__A::Error as _serde::de::Error>::duplicate_field(
4441                                            "minDesiredIslandSize",
4442                                        ),
4443                                    );
4444                                }
4445                                m_minDesiredIslandSize = _serde::__private::Some(
4446                                    match __A::next_value::<u32>(&mut __map) {
4447                                        _serde::__private::Ok(__val) => __val,
4448                                        _serde::__private::Err(__err) => {
4449                                            return _serde::__private::Err(__err);
4450                                        }
4451                                    },
4452                                );
4453                            }
4454                            __Field::m_processActionsInSingleThread => {
4455                                #[cfg(
4456                                    any(feature = "strict", feature = "ignore_duplicates")
4457                                )]
4458                                if _serde::__private::Option::is_some(
4459                                    &m_processActionsInSingleThread,
4460                                ) {
4461                                    #[cfg(feature = "ignore_duplicates")]
4462                                    {
4463                                        __A::skip_value(&mut __map)?;
4464                                        continue;
4465                                    }
4466                                    #[cfg(feature = "strict")]
4467                                    return _serde::__private::Err(
4468                                        <__A::Error as _serde::de::Error>::duplicate_field(
4469                                            "processActionsInSingleThread",
4470                                        ),
4471                                    );
4472                                }
4473                                m_processActionsInSingleThread = _serde::__private::Some(
4474                                    match __A::next_value::<bool>(&mut __map) {
4475                                        _serde::__private::Ok(__val) => __val,
4476                                        _serde::__private::Err(__err) => {
4477                                            return _serde::__private::Err(__err);
4478                                        }
4479                                    },
4480                                );
4481                            }
4482                            __Field::m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob => {
4483                                #[cfg(
4484                                    any(feature = "strict", feature = "ignore_duplicates")
4485                                )]
4486                                if _serde::__private::Option::is_some(
4487                                    &m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob,
4488                                ) {
4489                                    #[cfg(feature = "ignore_duplicates")]
4490                                    {
4491                                        __A::skip_value(&mut __map)?;
4492                                        continue;
4493                                    }
4494                                    #[cfg(feature = "strict")]
4495                                    return _serde::__private::Err(
4496                                        <__A::Error as _serde::de::Error>::duplicate_field(
4497                                            "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob",
4498                                        ),
4499                                    );
4500                                }
4501                                m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob = _serde::__private::Some(
4502                                    match __A::next_value::<bool>(&mut __map) {
4503                                        _serde::__private::Ok(__val) => __val,
4504                                        _serde::__private::Err(__err) => {
4505                                            return _serde::__private::Err(__err);
4506                                        }
4507                                    },
4508                                );
4509                            }
4510                            __Field::m_frameMarkerPsiSnap => {
4511                                #[cfg(
4512                                    any(feature = "strict", feature = "ignore_duplicates")
4513                                )]
4514                                if _serde::__private::Option::is_some(
4515                                    &m_frameMarkerPsiSnap,
4516                                ) {
4517                                    #[cfg(feature = "ignore_duplicates")]
4518                                    {
4519                                        __A::skip_value(&mut __map)?;
4520                                        continue;
4521                                    }
4522                                    #[cfg(feature = "strict")]
4523                                    return _serde::__private::Err(
4524                                        <__A::Error as _serde::de::Error>::duplicate_field(
4525                                            "frameMarkerPsiSnap",
4526                                        ),
4527                                    );
4528                                }
4529                                m_frameMarkerPsiSnap = _serde::__private::Some(
4530                                    match __A::next_value::<f32>(&mut __map) {
4531                                        _serde::__private::Ok(__val) => __val,
4532                                        _serde::__private::Err(__err) => {
4533                                            return _serde::__private::Err(__err);
4534                                        }
4535                                    },
4536                                );
4537                            }
4538                            __Field::m_fireCollisionCallbacks => {
4539                                #[cfg(
4540                                    any(feature = "strict", feature = "ignore_duplicates")
4541                                )]
4542                                if _serde::__private::Option::is_some(
4543                                    &m_fireCollisionCallbacks,
4544                                ) {
4545                                    #[cfg(feature = "ignore_duplicates")]
4546                                    {
4547                                        __A::skip_value(&mut __map)?;
4548                                        continue;
4549                                    }
4550                                    #[cfg(feature = "strict")]
4551                                    return _serde::__private::Err(
4552                                        <__A::Error as _serde::de::Error>::duplicate_field(
4553                                            "fireCollisionCallbacks",
4554                                        ),
4555                                    );
4556                                }
4557                                m_fireCollisionCallbacks = _serde::__private::Some(
4558                                    match __A::next_value::<bool>(&mut __map) {
4559                                        _serde::__private::Ok(__val) => __val,
4560                                        _serde::__private::Err(__err) => {
4561                                            return _serde::__private::Err(__err);
4562                                        }
4563                                    },
4564                                );
4565                            }
4566                            _ => __A::skip_value(&mut __map)?,
4567                        }
4568                    }
4569                    let m_gravity = match m_gravity {
4570                        _serde::__private::Some(__field) => __field,
4571                        _serde::__private::None => {
4572                            #[cfg(feature = "strict")]
4573                            return _serde::__private::Err(
4574                                <__A::Error as _serde::de::Error>::missing_field("gravity"),
4575                            );
4576                            #[cfg(not(feature = "strict"))] Default::default()
4577                        }
4578                    };
4579                    let m_broadPhaseQuerySize = match m_broadPhaseQuerySize {
4580                        _serde::__private::Some(__field) => __field,
4581                        _serde::__private::None => {
4582                            #[cfg(feature = "strict")]
4583                            return _serde::__private::Err(
4584                                <__A::Error as _serde::de::Error>::missing_field(
4585                                    "broadPhaseQuerySize",
4586                                ),
4587                            );
4588                            #[cfg(not(feature = "strict"))] Default::default()
4589                        }
4590                    };
4591                    let m_contactRestingVelocity = match m_contactRestingVelocity {
4592                        _serde::__private::Some(__field) => __field,
4593                        _serde::__private::None => {
4594                            #[cfg(feature = "strict")]
4595                            return _serde::__private::Err(
4596                                <__A::Error as _serde::de::Error>::missing_field(
4597                                    "contactRestingVelocity",
4598                                ),
4599                            );
4600                            #[cfg(not(feature = "strict"))] Default::default()
4601                        }
4602                    };
4603                    let m_broadPhaseBorderBehaviour = match m_broadPhaseBorderBehaviour {
4604                        _serde::__private::Some(__field) => __field,
4605                        _serde::__private::None => {
4606                            #[cfg(feature = "strict")]
4607                            return _serde::__private::Err(
4608                                <__A::Error as _serde::de::Error>::missing_field(
4609                                    "broadPhaseBorderBehaviour",
4610                                ),
4611                            );
4612                            #[cfg(not(feature = "strict"))] Default::default()
4613                        }
4614                    };
4615                    let m_mtPostponeAndSortBroadPhaseBorderCallbacks = match m_mtPostponeAndSortBroadPhaseBorderCallbacks {
4616                        _serde::__private::Some(__field) => __field,
4617                        _serde::__private::None => {
4618                            #[cfg(feature = "strict")]
4619                            return _serde::__private::Err(
4620                                <__A::Error as _serde::de::Error>::missing_field(
4621                                    "mtPostponeAndSortBroadPhaseBorderCallbacks",
4622                                ),
4623                            );
4624                            #[cfg(not(feature = "strict"))] Default::default()
4625                        }
4626                    };
4627                    let m_broadPhaseWorldAabb = match m_broadPhaseWorldAabb {
4628                        _serde::__private::Some(__field) => __field,
4629                        _serde::__private::None => {
4630                            #[cfg(feature = "strict")]
4631                            return _serde::__private::Err(
4632                                <__A::Error as _serde::de::Error>::missing_field(
4633                                    "broadPhaseWorldAabb",
4634                                ),
4635                            );
4636                            #[cfg(not(feature = "strict"))] Default::default()
4637                        }
4638                    };
4639                    let m_useKdTree = match m_useKdTree {
4640                        _serde::__private::Some(__field) => __field,
4641                        _serde::__private::None => {
4642                            #[cfg(feature = "strict")]
4643                            return _serde::__private::Err(
4644                                <__A::Error as _serde::de::Error>::missing_field(
4645                                    "useKdTree",
4646                                ),
4647                            );
4648                            #[cfg(not(feature = "strict"))] Default::default()
4649                        }
4650                    };
4651                    let m_useMultipleTree = match m_useMultipleTree {
4652                        _serde::__private::Some(__field) => __field,
4653                        _serde::__private::None => {
4654                            #[cfg(feature = "strict")]
4655                            return _serde::__private::Err(
4656                                <__A::Error as _serde::de::Error>::missing_field(
4657                                    "useMultipleTree",
4658                                ),
4659                            );
4660                            #[cfg(not(feature = "strict"))] Default::default()
4661                        }
4662                    };
4663                    let m_treeUpdateType = match m_treeUpdateType {
4664                        _serde::__private::Some(__field) => __field,
4665                        _serde::__private::None => {
4666                            #[cfg(feature = "strict")]
4667                            return _serde::__private::Err(
4668                                <__A::Error as _serde::de::Error>::missing_field(
4669                                    "treeUpdateType",
4670                                ),
4671                            );
4672                            #[cfg(not(feature = "strict"))] Default::default()
4673                        }
4674                    };
4675                    let m_autoUpdateKdTree = match m_autoUpdateKdTree {
4676                        _serde::__private::Some(__field) => __field,
4677                        _serde::__private::None => {
4678                            #[cfg(feature = "strict")]
4679                            return _serde::__private::Err(
4680                                <__A::Error as _serde::de::Error>::missing_field(
4681                                    "autoUpdateKdTree",
4682                                ),
4683                            );
4684                            #[cfg(not(feature = "strict"))] Default::default()
4685                        }
4686                    };
4687                    let m_collisionTolerance = match m_collisionTolerance {
4688                        _serde::__private::Some(__field) => __field,
4689                        _serde::__private::None => {
4690                            #[cfg(feature = "strict")]
4691                            return _serde::__private::Err(
4692                                <__A::Error as _serde::de::Error>::missing_field(
4693                                    "collisionTolerance",
4694                                ),
4695                            );
4696                            #[cfg(not(feature = "strict"))] Default::default()
4697                        }
4698                    };
4699                    let m_collisionFilter = match m_collisionFilter {
4700                        _serde::__private::Some(__field) => __field,
4701                        _serde::__private::None => {
4702                            #[cfg(feature = "strict")]
4703                            return _serde::__private::Err(
4704                                <__A::Error as _serde::de::Error>::missing_field(
4705                                    "collisionFilter",
4706                                ),
4707                            );
4708                            #[cfg(not(feature = "strict"))] Default::default()
4709                        }
4710                    };
4711                    let m_convexListFilter = match m_convexListFilter {
4712                        _serde::__private::Some(__field) => __field,
4713                        _serde::__private::None => {
4714                            #[cfg(feature = "strict")]
4715                            return _serde::__private::Err(
4716                                <__A::Error as _serde::de::Error>::missing_field(
4717                                    "convexListFilter",
4718                                ),
4719                            );
4720                            #[cfg(not(feature = "strict"))] Default::default()
4721                        }
4722                    };
4723                    let m_expectedMaxLinearVelocity = match m_expectedMaxLinearVelocity {
4724                        _serde::__private::Some(__field) => __field,
4725                        _serde::__private::None => {
4726                            #[cfg(feature = "strict")]
4727                            return _serde::__private::Err(
4728                                <__A::Error as _serde::de::Error>::missing_field(
4729                                    "expectedMaxLinearVelocity",
4730                                ),
4731                            );
4732                            #[cfg(not(feature = "strict"))] Default::default()
4733                        }
4734                    };
4735                    let m_sizeOfToiEventQueue = match m_sizeOfToiEventQueue {
4736                        _serde::__private::Some(__field) => __field,
4737                        _serde::__private::None => {
4738                            #[cfg(feature = "strict")]
4739                            return _serde::__private::Err(
4740                                <__A::Error as _serde::de::Error>::missing_field(
4741                                    "sizeOfToiEventQueue",
4742                                ),
4743                            );
4744                            #[cfg(not(feature = "strict"))] Default::default()
4745                        }
4746                    };
4747                    let m_expectedMinPsiDeltaTime = match m_expectedMinPsiDeltaTime {
4748                        _serde::__private::Some(__field) => __field,
4749                        _serde::__private::None => {
4750                            #[cfg(feature = "strict")]
4751                            return _serde::__private::Err(
4752                                <__A::Error as _serde::de::Error>::missing_field(
4753                                    "expectedMinPsiDeltaTime",
4754                                ),
4755                            );
4756                            #[cfg(not(feature = "strict"))] Default::default()
4757                        }
4758                    };
4759                    let m_memoryWatchDog = match m_memoryWatchDog {
4760                        _serde::__private::Some(__field) => __field,
4761                        _serde::__private::None => {
4762                            #[cfg(feature = "strict")]
4763                            return _serde::__private::Err(
4764                                <__A::Error as _serde::de::Error>::missing_field(
4765                                    "memoryWatchDog",
4766                                ),
4767                            );
4768                            #[cfg(not(feature = "strict"))] Default::default()
4769                        }
4770                    };
4771                    let m_broadPhaseNumMarkers = match m_broadPhaseNumMarkers {
4772                        _serde::__private::Some(__field) => __field,
4773                        _serde::__private::None => {
4774                            #[cfg(feature = "strict")]
4775                            return _serde::__private::Err(
4776                                <__A::Error as _serde::de::Error>::missing_field(
4777                                    "broadPhaseNumMarkers",
4778                                ),
4779                            );
4780                            #[cfg(not(feature = "strict"))] Default::default()
4781                        }
4782                    };
4783                    let m_contactPointGeneration = match m_contactPointGeneration {
4784                        _serde::__private::Some(__field) => __field,
4785                        _serde::__private::None => {
4786                            #[cfg(feature = "strict")]
4787                            return _serde::__private::Err(
4788                                <__A::Error as _serde::de::Error>::missing_field(
4789                                    "contactPointGeneration",
4790                                ),
4791                            );
4792                            #[cfg(not(feature = "strict"))] Default::default()
4793                        }
4794                    };
4795                    let m_allowToSkipConfirmedCallbacks = match m_allowToSkipConfirmedCallbacks {
4796                        _serde::__private::Some(__field) => __field,
4797                        _serde::__private::None => {
4798                            #[cfg(feature = "strict")]
4799                            return _serde::__private::Err(
4800                                <__A::Error as _serde::de::Error>::missing_field(
4801                                    "allowToSkipConfirmedCallbacks",
4802                                ),
4803                            );
4804                            #[cfg(not(feature = "strict"))] Default::default()
4805                        }
4806                    };
4807                    let m_useHybridBroadphase = match m_useHybridBroadphase {
4808                        _serde::__private::Some(__field) => __field,
4809                        _serde::__private::None => {
4810                            #[cfg(feature = "strict")]
4811                            return _serde::__private::Err(
4812                                <__A::Error as _serde::de::Error>::missing_field(
4813                                    "useHybridBroadphase",
4814                                ),
4815                            );
4816                            #[cfg(not(feature = "strict"))] Default::default()
4817                        }
4818                    };
4819                    let m_solverTau = match m_solverTau {
4820                        _serde::__private::Some(__field) => __field,
4821                        _serde::__private::None => {
4822                            #[cfg(feature = "strict")]
4823                            return _serde::__private::Err(
4824                                <__A::Error as _serde::de::Error>::missing_field(
4825                                    "solverTau",
4826                                ),
4827                            );
4828                            #[cfg(not(feature = "strict"))] Default::default()
4829                        }
4830                    };
4831                    let m_solverDamp = match m_solverDamp {
4832                        _serde::__private::Some(__field) => __field,
4833                        _serde::__private::None => {
4834                            #[cfg(feature = "strict")]
4835                            return _serde::__private::Err(
4836                                <__A::Error as _serde::de::Error>::missing_field(
4837                                    "solverDamp",
4838                                ),
4839                            );
4840                            #[cfg(not(feature = "strict"))] Default::default()
4841                        }
4842                    };
4843                    let m_solverIterations = match m_solverIterations {
4844                        _serde::__private::Some(__field) => __field,
4845                        _serde::__private::None => {
4846                            #[cfg(feature = "strict")]
4847                            return _serde::__private::Err(
4848                                <__A::Error as _serde::de::Error>::missing_field(
4849                                    "solverIterations",
4850                                ),
4851                            );
4852                            #[cfg(not(feature = "strict"))] Default::default()
4853                        }
4854                    };
4855                    let m_solverMicrosteps = match m_solverMicrosteps {
4856                        _serde::__private::Some(__field) => __field,
4857                        _serde::__private::None => {
4858                            #[cfg(feature = "strict")]
4859                            return _serde::__private::Err(
4860                                <__A::Error as _serde::de::Error>::missing_field(
4861                                    "solverMicrosteps",
4862                                ),
4863                            );
4864                            #[cfg(not(feature = "strict"))] Default::default()
4865                        }
4866                    };
4867                    let m_maxConstraintViolation = match m_maxConstraintViolation {
4868                        _serde::__private::Some(__field) => __field,
4869                        _serde::__private::None => {
4870                            #[cfg(feature = "strict")]
4871                            return _serde::__private::Err(
4872                                <__A::Error as _serde::de::Error>::missing_field(
4873                                    "maxConstraintViolation",
4874                                ),
4875                            );
4876                            #[cfg(not(feature = "strict"))] Default::default()
4877                        }
4878                    };
4879                    let m_forceCoherentConstraintOrderingInSolver = match m_forceCoherentConstraintOrderingInSolver {
4880                        _serde::__private::Some(__field) => __field,
4881                        _serde::__private::None => {
4882                            #[cfg(feature = "strict")]
4883                            return _serde::__private::Err(
4884                                <__A::Error as _serde::de::Error>::missing_field(
4885                                    "forceCoherentConstraintOrderingInSolver",
4886                                ),
4887                            );
4888                            #[cfg(not(feature = "strict"))] Default::default()
4889                        }
4890                    };
4891                    let m_snapCollisionToConvexEdgeThreshold = match m_snapCollisionToConvexEdgeThreshold {
4892                        _serde::__private::Some(__field) => __field,
4893                        _serde::__private::None => {
4894                            #[cfg(feature = "strict")]
4895                            return _serde::__private::Err(
4896                                <__A::Error as _serde::de::Error>::missing_field(
4897                                    "snapCollisionToConvexEdgeThreshold",
4898                                ),
4899                            );
4900                            #[cfg(not(feature = "strict"))] Default::default()
4901                        }
4902                    };
4903                    let m_snapCollisionToConcaveEdgeThreshold = match m_snapCollisionToConcaveEdgeThreshold {
4904                        _serde::__private::Some(__field) => __field,
4905                        _serde::__private::None => {
4906                            #[cfg(feature = "strict")]
4907                            return _serde::__private::Err(
4908                                <__A::Error as _serde::de::Error>::missing_field(
4909                                    "snapCollisionToConcaveEdgeThreshold",
4910                                ),
4911                            );
4912                            #[cfg(not(feature = "strict"))] Default::default()
4913                        }
4914                    };
4915                    let m_enableToiWeldRejection = match m_enableToiWeldRejection {
4916                        _serde::__private::Some(__field) => __field,
4917                        _serde::__private::None => {
4918                            #[cfg(feature = "strict")]
4919                            return _serde::__private::Err(
4920                                <__A::Error as _serde::de::Error>::missing_field(
4921                                    "enableToiWeldRejection",
4922                                ),
4923                            );
4924                            #[cfg(not(feature = "strict"))] Default::default()
4925                        }
4926                    };
4927                    let m_enableDeprecatedWelding = match m_enableDeprecatedWelding {
4928                        _serde::__private::Some(__field) => __field,
4929                        _serde::__private::None => {
4930                            #[cfg(feature = "strict")]
4931                            return _serde::__private::Err(
4932                                <__A::Error as _serde::de::Error>::missing_field(
4933                                    "enableDeprecatedWelding",
4934                                ),
4935                            );
4936                            #[cfg(not(feature = "strict"))] Default::default()
4937                        }
4938                    };
4939                    let m_iterativeLinearCastEarlyOutDistance = match m_iterativeLinearCastEarlyOutDistance {
4940                        _serde::__private::Some(__field) => __field,
4941                        _serde::__private::None => {
4942                            #[cfg(feature = "strict")]
4943                            return _serde::__private::Err(
4944                                <__A::Error as _serde::de::Error>::missing_field(
4945                                    "iterativeLinearCastEarlyOutDistance",
4946                                ),
4947                            );
4948                            #[cfg(not(feature = "strict"))] Default::default()
4949                        }
4950                    };
4951                    let m_iterativeLinearCastMaxIterations = match m_iterativeLinearCastMaxIterations {
4952                        _serde::__private::Some(__field) => __field,
4953                        _serde::__private::None => {
4954                            #[cfg(feature = "strict")]
4955                            return _serde::__private::Err(
4956                                <__A::Error as _serde::de::Error>::missing_field(
4957                                    "iterativeLinearCastMaxIterations",
4958                                ),
4959                            );
4960                            #[cfg(not(feature = "strict"))] Default::default()
4961                        }
4962                    };
4963                    let m_deactivationNumInactiveFramesSelectFlag0 = match m_deactivationNumInactiveFramesSelectFlag0 {
4964                        _serde::__private::Some(__field) => __field,
4965                        _serde::__private::None => {
4966                            #[cfg(feature = "strict")]
4967                            return _serde::__private::Err(
4968                                <__A::Error as _serde::de::Error>::missing_field(
4969                                    "deactivationNumInactiveFramesSelectFlag0",
4970                                ),
4971                            );
4972                            #[cfg(not(feature = "strict"))] Default::default()
4973                        }
4974                    };
4975                    let m_deactivationNumInactiveFramesSelectFlag1 = match m_deactivationNumInactiveFramesSelectFlag1 {
4976                        _serde::__private::Some(__field) => __field,
4977                        _serde::__private::None => {
4978                            #[cfg(feature = "strict")]
4979                            return _serde::__private::Err(
4980                                <__A::Error as _serde::de::Error>::missing_field(
4981                                    "deactivationNumInactiveFramesSelectFlag1",
4982                                ),
4983                            );
4984                            #[cfg(not(feature = "strict"))] Default::default()
4985                        }
4986                    };
4987                    let m_deactivationIntegrateCounter = match m_deactivationIntegrateCounter {
4988                        _serde::__private::Some(__field) => __field,
4989                        _serde::__private::None => {
4990                            #[cfg(feature = "strict")]
4991                            return _serde::__private::Err(
4992                                <__A::Error as _serde::de::Error>::missing_field(
4993                                    "deactivationIntegrateCounter",
4994                                ),
4995                            );
4996                            #[cfg(not(feature = "strict"))] Default::default()
4997                        }
4998                    };
4999                    let m_shouldActivateOnRigidBodyTransformChange = match m_shouldActivateOnRigidBodyTransformChange {
5000                        _serde::__private::Some(__field) => __field,
5001                        _serde::__private::None => {
5002                            #[cfg(feature = "strict")]
5003                            return _serde::__private::Err(
5004                                <__A::Error as _serde::de::Error>::missing_field(
5005                                    "shouldActivateOnRigidBodyTransformChange",
5006                                ),
5007                            );
5008                            #[cfg(not(feature = "strict"))] Default::default()
5009                        }
5010                    };
5011                    let m_deactivationReferenceDistance = match m_deactivationReferenceDistance {
5012                        _serde::__private::Some(__field) => __field,
5013                        _serde::__private::None => {
5014                            #[cfg(feature = "strict")]
5015                            return _serde::__private::Err(
5016                                <__A::Error as _serde::de::Error>::missing_field(
5017                                    "deactivationReferenceDistance",
5018                                ),
5019                            );
5020                            #[cfg(not(feature = "strict"))] Default::default()
5021                        }
5022                    };
5023                    let m_toiCollisionResponseRotateNormal = match m_toiCollisionResponseRotateNormal {
5024                        _serde::__private::Some(__field) => __field,
5025                        _serde::__private::None => {
5026                            #[cfg(feature = "strict")]
5027                            return _serde::__private::Err(
5028                                <__A::Error as _serde::de::Error>::missing_field(
5029                                    "toiCollisionResponseRotateNormal",
5030                                ),
5031                            );
5032                            #[cfg(not(feature = "strict"))] Default::default()
5033                        }
5034                    };
5035                    let m_maxSectorsPerMidphaseCollideTask = match m_maxSectorsPerMidphaseCollideTask {
5036                        _serde::__private::Some(__field) => __field,
5037                        _serde::__private::None => {
5038                            #[cfg(feature = "strict")]
5039                            return _serde::__private::Err(
5040                                <__A::Error as _serde::de::Error>::missing_field(
5041                                    "maxSectorsPerMidphaseCollideTask",
5042                                ),
5043                            );
5044                            #[cfg(not(feature = "strict"))] Default::default()
5045                        }
5046                    };
5047                    let m_maxSectorsPerNarrowphaseCollideTask = match m_maxSectorsPerNarrowphaseCollideTask {
5048                        _serde::__private::Some(__field) => __field,
5049                        _serde::__private::None => {
5050                            #[cfg(feature = "strict")]
5051                            return _serde::__private::Err(
5052                                <__A::Error as _serde::de::Error>::missing_field(
5053                                    "maxSectorsPerNarrowphaseCollideTask",
5054                                ),
5055                            );
5056                            #[cfg(not(feature = "strict"))] Default::default()
5057                        }
5058                    };
5059                    let m_processToisMultithreaded = match m_processToisMultithreaded {
5060                        _serde::__private::Some(__field) => __field,
5061                        _serde::__private::None => {
5062                            #[cfg(feature = "strict")]
5063                            return _serde::__private::Err(
5064                                <__A::Error as _serde::de::Error>::missing_field(
5065                                    "processToisMultithreaded",
5066                                ),
5067                            );
5068                            #[cfg(not(feature = "strict"))] Default::default()
5069                        }
5070                    };
5071                    let m_maxEntriesPerToiMidphaseCollideTask = match m_maxEntriesPerToiMidphaseCollideTask {
5072                        _serde::__private::Some(__field) => __field,
5073                        _serde::__private::None => {
5074                            #[cfg(feature = "strict")]
5075                            return _serde::__private::Err(
5076                                <__A::Error as _serde::de::Error>::missing_field(
5077                                    "maxEntriesPerToiMidphaseCollideTask",
5078                                ),
5079                            );
5080                            #[cfg(not(feature = "strict"))] Default::default()
5081                        }
5082                    };
5083                    let m_maxEntriesPerToiNarrowphaseCollideTask = match m_maxEntriesPerToiNarrowphaseCollideTask {
5084                        _serde::__private::Some(__field) => __field,
5085                        _serde::__private::None => {
5086                            #[cfg(feature = "strict")]
5087                            return _serde::__private::Err(
5088                                <__A::Error as _serde::de::Error>::missing_field(
5089                                    "maxEntriesPerToiNarrowphaseCollideTask",
5090                                ),
5091                            );
5092                            #[cfg(not(feature = "strict"))] Default::default()
5093                        }
5094                    };
5095                    let m_maxNumToiCollisionPairsSinglethreaded = match m_maxNumToiCollisionPairsSinglethreaded {
5096                        _serde::__private::Some(__field) => __field,
5097                        _serde::__private::None => {
5098                            #[cfg(feature = "strict")]
5099                            return _serde::__private::Err(
5100                                <__A::Error as _serde::de::Error>::missing_field(
5101                                    "maxNumToiCollisionPairsSinglethreaded",
5102                                ),
5103                            );
5104                            #[cfg(not(feature = "strict"))] Default::default()
5105                        }
5106                    };
5107                    let m_numToisTillAllowedPenetrationSimplifiedToi = match m_numToisTillAllowedPenetrationSimplifiedToi {
5108                        _serde::__private::Some(__field) => __field,
5109                        _serde::__private::None => {
5110                            #[cfg(feature = "strict")]
5111                            return _serde::__private::Err(
5112                                <__A::Error as _serde::de::Error>::missing_field(
5113                                    "numToisTillAllowedPenetrationSimplifiedToi",
5114                                ),
5115                            );
5116                            #[cfg(not(feature = "strict"))] Default::default()
5117                        }
5118                    };
5119                    let m_numToisTillAllowedPenetrationToi = match m_numToisTillAllowedPenetrationToi {
5120                        _serde::__private::Some(__field) => __field,
5121                        _serde::__private::None => {
5122                            #[cfg(feature = "strict")]
5123                            return _serde::__private::Err(
5124                                <__A::Error as _serde::de::Error>::missing_field(
5125                                    "numToisTillAllowedPenetrationToi",
5126                                ),
5127                            );
5128                            #[cfg(not(feature = "strict"))] Default::default()
5129                        }
5130                    };
5131                    let m_numToisTillAllowedPenetrationToiHigher = match m_numToisTillAllowedPenetrationToiHigher {
5132                        _serde::__private::Some(__field) => __field,
5133                        _serde::__private::None => {
5134                            #[cfg(feature = "strict")]
5135                            return _serde::__private::Err(
5136                                <__A::Error as _serde::de::Error>::missing_field(
5137                                    "numToisTillAllowedPenetrationToiHigher",
5138                                ),
5139                            );
5140                            #[cfg(not(feature = "strict"))] Default::default()
5141                        }
5142                    };
5143                    let m_numToisTillAllowedPenetrationToiForced = match m_numToisTillAllowedPenetrationToiForced {
5144                        _serde::__private::Some(__field) => __field,
5145                        _serde::__private::None => {
5146                            #[cfg(feature = "strict")]
5147                            return _serde::__private::Err(
5148                                <__A::Error as _serde::de::Error>::missing_field(
5149                                    "numToisTillAllowedPenetrationToiForced",
5150                                ),
5151                            );
5152                            #[cfg(not(feature = "strict"))] Default::default()
5153                        }
5154                    };
5155                    let m_enableDeactivation = match m_enableDeactivation {
5156                        _serde::__private::Some(__field) => __field,
5157                        _serde::__private::None => {
5158                            #[cfg(feature = "strict")]
5159                            return _serde::__private::Err(
5160                                <__A::Error as _serde::de::Error>::missing_field(
5161                                    "enableDeactivation",
5162                                ),
5163                            );
5164                            #[cfg(not(feature = "strict"))] Default::default()
5165                        }
5166                    };
5167                    let m_simulationType = match m_simulationType {
5168                        _serde::__private::Some(__field) => __field,
5169                        _serde::__private::None => {
5170                            #[cfg(feature = "strict")]
5171                            return _serde::__private::Err(
5172                                <__A::Error as _serde::de::Error>::missing_field(
5173                                    "simulationType",
5174                                ),
5175                            );
5176                            #[cfg(not(feature = "strict"))] Default::default()
5177                        }
5178                    };
5179                    let m_enableSimulationIslands = match m_enableSimulationIslands {
5180                        _serde::__private::Some(__field) => __field,
5181                        _serde::__private::None => {
5182                            #[cfg(feature = "strict")]
5183                            return _serde::__private::Err(
5184                                <__A::Error as _serde::de::Error>::missing_field(
5185                                    "enableSimulationIslands",
5186                                ),
5187                            );
5188                            #[cfg(not(feature = "strict"))] Default::default()
5189                        }
5190                    };
5191                    let m_minDesiredIslandSize = match m_minDesiredIslandSize {
5192                        _serde::__private::Some(__field) => __field,
5193                        _serde::__private::None => {
5194                            #[cfg(feature = "strict")]
5195                            return _serde::__private::Err(
5196                                <__A::Error as _serde::de::Error>::missing_field(
5197                                    "minDesiredIslandSize",
5198                                ),
5199                            );
5200                            #[cfg(not(feature = "strict"))] Default::default()
5201                        }
5202                    };
5203                    let m_processActionsInSingleThread = match m_processActionsInSingleThread {
5204                        _serde::__private::Some(__field) => __field,
5205                        _serde::__private::None => {
5206                            #[cfg(feature = "strict")]
5207                            return _serde::__private::Err(
5208                                <__A::Error as _serde::de::Error>::missing_field(
5209                                    "processActionsInSingleThread",
5210                                ),
5211                            );
5212                            #[cfg(not(feature = "strict"))] Default::default()
5213                        }
5214                    };
5215                    let m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob = match m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob {
5216                        _serde::__private::Some(__field) => __field,
5217                        _serde::__private::None => {
5218                            #[cfg(feature = "strict")]
5219                            return _serde::__private::Err(
5220                                <__A::Error as _serde::de::Error>::missing_field(
5221                                    "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob",
5222                                ),
5223                            );
5224                            #[cfg(not(feature = "strict"))] Default::default()
5225                        }
5226                    };
5227                    let m_frameMarkerPsiSnap = match m_frameMarkerPsiSnap {
5228                        _serde::__private::Some(__field) => __field,
5229                        _serde::__private::None => {
5230                            #[cfg(feature = "strict")]
5231                            return _serde::__private::Err(
5232                                <__A::Error as _serde::de::Error>::missing_field(
5233                                    "frameMarkerPsiSnap",
5234                                ),
5235                            );
5236                            #[cfg(not(feature = "strict"))] Default::default()
5237                        }
5238                    };
5239                    let m_fireCollisionCallbacks = match m_fireCollisionCallbacks {
5240                        _serde::__private::Some(__field) => __field,
5241                        _serde::__private::None => {
5242                            #[cfg(feature = "strict")]
5243                            return _serde::__private::Err(
5244                                <__A::Error as _serde::de::Error>::missing_field(
5245                                    "fireCollisionCallbacks",
5246                                ),
5247                            );
5248                            #[cfg(not(feature = "strict"))] Default::default()
5249                        }
5250                    };
5251                    let __ptr = None;
5252                    let parent = hkBaseObject { __ptr };
5253                    let parent = hkReferencedObject {
5254                        __ptr,
5255                        parent,
5256                        ..Default::default()
5257                    };
5258                    let __ptr = __A::class_ptr(&mut __map);
5259                    _serde::__private::Ok(hkpWorldCinfo {
5260                        __ptr,
5261                        parent,
5262                        m_gravity,
5263                        m_broadPhaseQuerySize,
5264                        m_contactRestingVelocity,
5265                        m_broadPhaseBorderBehaviour,
5266                        m_mtPostponeAndSortBroadPhaseBorderCallbacks,
5267                        m_broadPhaseWorldAabb,
5268                        m_useKdTree,
5269                        m_useMultipleTree,
5270                        m_treeUpdateType,
5271                        m_autoUpdateKdTree,
5272                        m_collisionTolerance,
5273                        m_collisionFilter,
5274                        m_convexListFilter,
5275                        m_expectedMaxLinearVelocity,
5276                        m_sizeOfToiEventQueue,
5277                        m_expectedMinPsiDeltaTime,
5278                        m_memoryWatchDog,
5279                        m_broadPhaseNumMarkers,
5280                        m_contactPointGeneration,
5281                        m_allowToSkipConfirmedCallbacks,
5282                        m_useHybridBroadphase,
5283                        m_solverTau,
5284                        m_solverDamp,
5285                        m_solverIterations,
5286                        m_solverMicrosteps,
5287                        m_maxConstraintViolation,
5288                        m_forceCoherentConstraintOrderingInSolver,
5289                        m_snapCollisionToConvexEdgeThreshold,
5290                        m_snapCollisionToConcaveEdgeThreshold,
5291                        m_enableToiWeldRejection,
5292                        m_enableDeprecatedWelding,
5293                        m_iterativeLinearCastEarlyOutDistance,
5294                        m_iterativeLinearCastMaxIterations,
5295                        m_deactivationNumInactiveFramesSelectFlag0,
5296                        m_deactivationNumInactiveFramesSelectFlag1,
5297                        m_deactivationIntegrateCounter,
5298                        m_shouldActivateOnRigidBodyTransformChange,
5299                        m_deactivationReferenceDistance,
5300                        m_toiCollisionResponseRotateNormal,
5301                        m_maxSectorsPerMidphaseCollideTask,
5302                        m_maxSectorsPerNarrowphaseCollideTask,
5303                        m_processToisMultithreaded,
5304                        m_maxEntriesPerToiMidphaseCollideTask,
5305                        m_maxEntriesPerToiNarrowphaseCollideTask,
5306                        m_maxNumToiCollisionPairsSinglethreaded,
5307                        m_numToisTillAllowedPenetrationSimplifiedToi,
5308                        m_numToisTillAllowedPenetrationToi,
5309                        m_numToisTillAllowedPenetrationToiHigher,
5310                        m_numToisTillAllowedPenetrationToiForced,
5311                        m_enableDeactivation,
5312                        m_simulationType,
5313                        m_enableSimulationIslands,
5314                        m_minDesiredIslandSize,
5315                        m_processActionsInSingleThread,
5316                        m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob,
5317                        m_frameMarkerPsiSnap,
5318                        m_fireCollisionCallbacks,
5319                    })
5320                }
5321            }
5322            const FIELDS: &[&str] = &[
5323                "gravity",
5324                "broadPhaseQuerySize",
5325                "contactRestingVelocity",
5326                "broadPhaseBorderBehaviour",
5327                "mtPostponeAndSortBroadPhaseBorderCallbacks",
5328                "broadPhaseWorldAabb",
5329                "useKdTree",
5330                "useMultipleTree",
5331                "treeUpdateType",
5332                "autoUpdateKdTree",
5333                "collisionTolerance",
5334                "collisionFilter",
5335                "convexListFilter",
5336                "expectedMaxLinearVelocity",
5337                "sizeOfToiEventQueue",
5338                "expectedMinPsiDeltaTime",
5339                "memoryWatchDog",
5340                "broadPhaseNumMarkers",
5341                "contactPointGeneration",
5342                "allowToSkipConfirmedCallbacks",
5343                "useHybridBroadphase",
5344                "solverTau",
5345                "solverDamp",
5346                "solverIterations",
5347                "solverMicrosteps",
5348                "maxConstraintViolation",
5349                "forceCoherentConstraintOrderingInSolver",
5350                "snapCollisionToConvexEdgeThreshold",
5351                "snapCollisionToConcaveEdgeThreshold",
5352                "enableToiWeldRejection",
5353                "enableDeprecatedWelding",
5354                "iterativeLinearCastEarlyOutDistance",
5355                "iterativeLinearCastMaxIterations",
5356                "deactivationNumInactiveFramesSelectFlag0",
5357                "deactivationNumInactiveFramesSelectFlag1",
5358                "deactivationIntegrateCounter",
5359                "shouldActivateOnRigidBodyTransformChange",
5360                "deactivationReferenceDistance",
5361                "toiCollisionResponseRotateNormal",
5362                "maxSectorsPerMidphaseCollideTask",
5363                "maxSectorsPerNarrowphaseCollideTask",
5364                "processToisMultithreaded",
5365                "maxEntriesPerToiMidphaseCollideTask",
5366                "maxEntriesPerToiNarrowphaseCollideTask",
5367                "maxNumToiCollisionPairsSinglethreaded",
5368                "numToisTillAllowedPenetrationSimplifiedToi",
5369                "numToisTillAllowedPenetrationToi",
5370                "numToisTillAllowedPenetrationToiHigher",
5371                "numToisTillAllowedPenetrationToiForced",
5372                "enableDeactivation",
5373                "simulationType",
5374                "enableSimulationIslands",
5375                "minDesiredIslandSize",
5376                "processActionsInSingleThread",
5377                "allowIntegrationOfIslandsWithoutConstraintsInASeparateJob",
5378                "frameMarkerPsiSnap",
5379                "fireCollisionCallbacks",
5380            ];
5381            _serde::Deserializer::deserialize_struct(
5382                deserializer,
5383                "hkpWorldCinfo",
5384                FIELDS,
5385                __hkpWorldCinfoVisitor {
5386                    marker: _serde::__private::PhantomData::<hkpWorldCinfo>,
5387                    lifetime: _serde::__private::PhantomData,
5388                },
5389            )
5390        }
5391    }
5392};
5393/// # C++ Info
5394/// - name: `SimulationType`(ctype: `hkEnum<SimulationType, hkInt8>`)
5395#[allow(non_upper_case_globals, non_snake_case)]
5396#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
5397#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5398#[derive(
5399    Debug,
5400    Clone,
5401    Default,
5402    PartialEq,
5403    Eq,
5404    PartialOrd,
5405    Ord,
5406    num_derive::ToPrimitive,
5407    num_derive::FromPrimitive,
5408)]
5409pub enum SimulationType {
5410    #[default]
5411    SIMULATION_TYPE_INVALID = 0isize,
5412    SIMULATION_TYPE_DISCRETE = 1isize,
5413    SIMULATION_TYPE_CONTINUOUS = 2isize,
5414    SIMULATION_TYPE_MULTITHREADED = 3isize,
5415}
5416/// # C++ Info
5417/// - name: `ContactPointGeneration`(ctype: `hkEnum<ContactPointGeneration, hkInt8>`)
5418#[allow(non_upper_case_globals, non_snake_case)]
5419#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
5420#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5421#[derive(
5422    Debug,
5423    Clone,
5424    Default,
5425    PartialEq,
5426    Eq,
5427    PartialOrd,
5428    Ord,
5429    num_derive::ToPrimitive,
5430    num_derive::FromPrimitive,
5431)]
5432pub enum ContactPointGeneration {
5433    #[default]
5434    CONTACT_POINT_ACCEPT_ALWAYS = 0isize,
5435    CONTACT_POINT_REJECT_DUBIOUS = 1isize,
5436    CONTACT_POINT_REJECT_MANY = 2isize,
5437}
5438/// # C++ Info
5439/// - name: `BroadPhaseBorderBehaviour`(ctype: `hkEnum<BroadPhaseBorderBehaviour, hkInt8>`)
5440#[allow(non_upper_case_globals, non_snake_case)]
5441#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
5442#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5443#[derive(
5444    Debug,
5445    Clone,
5446    Default,
5447    PartialEq,
5448    Eq,
5449    PartialOrd,
5450    Ord,
5451    num_derive::ToPrimitive,
5452    num_derive::FromPrimitive,
5453)]
5454pub enum BroadPhaseBorderBehaviour {
5455    #[default]
5456    BROADPHASE_BORDER_ASSERT = 0isize,
5457    BROADPHASE_BORDER_FIX_ENTITY = 1isize,
5458    BROADPHASE_BORDER_REMOVE_ENTITY = 2isize,
5459    BROADPHASE_BORDER_DO_NOTHING = 3isize,
5460}
5461/// # C++ Info
5462/// - name: `TreeUpdateType`(ctype: `hkEnum<TreeUpdateType, hkInt8>`)
5463#[allow(non_upper_case_globals, non_snake_case)]
5464#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
5465#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5466#[derive(
5467    Debug,
5468    Clone,
5469    Default,
5470    PartialEq,
5471    Eq,
5472    PartialOrd,
5473    Ord,
5474    num_derive::ToPrimitive,
5475    num_derive::FromPrimitive,
5476)]
5477pub enum TreeUpdateType {
5478    #[default]
5479    REBUILD_ACTIVE = 0isize,
5480    REBUILD_ALL = 1isize,
5481}
5482const _: () = {
5483    use havok_serde as __serde;
5484    impl __serde::Serialize for SimulationType {
5485        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
5486        where
5487            S: __serde::ser::Serializer,
5488        {
5489            let mut __serializer = __serializer.serialize_enum_flags()?;
5490            match self {
5491                Self::SIMULATION_TYPE_INVALID => {
5492                    __serializer.serialize_field("SIMULATION_TYPE_INVALID", &0u64)
5493                }
5494                Self::SIMULATION_TYPE_DISCRETE => {
5495                    __serializer.serialize_field("SIMULATION_TYPE_DISCRETE", &1u64)
5496                }
5497                Self::SIMULATION_TYPE_CONTINUOUS => {
5498                    __serializer.serialize_field("SIMULATION_TYPE_CONTINUOUS", &2u64)
5499                }
5500                Self::SIMULATION_TYPE_MULTITHREADED => {
5501                    __serializer.serialize_field("SIMULATION_TYPE_MULTITHREADED", &3u64)
5502                }
5503            }?;
5504            use num_traits::ToPrimitive as _;
5505            let num = self
5506                .to_i8()
5507                .ok_or(S::Error::custom("Failed enum SimulationType to_i8"))?;
5508            __serializer.serialize_bits(&num)?;
5509            __serializer.end()
5510        }
5511    }
5512};
5513const _: () = {
5514    use havok_serde as __serde;
5515    impl __serde::Serialize for ContactPointGeneration {
5516        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
5517        where
5518            S: __serde::ser::Serializer,
5519        {
5520            let mut __serializer = __serializer.serialize_enum_flags()?;
5521            match self {
5522                Self::CONTACT_POINT_ACCEPT_ALWAYS => {
5523                    __serializer.serialize_field("CONTACT_POINT_ACCEPT_ALWAYS", &0u64)
5524                }
5525                Self::CONTACT_POINT_REJECT_DUBIOUS => {
5526                    __serializer.serialize_field("CONTACT_POINT_REJECT_DUBIOUS", &1u64)
5527                }
5528                Self::CONTACT_POINT_REJECT_MANY => {
5529                    __serializer.serialize_field("CONTACT_POINT_REJECT_MANY", &2u64)
5530                }
5531            }?;
5532            use num_traits::ToPrimitive as _;
5533            let num = self
5534                .to_i8()
5535                .ok_or(S::Error::custom("Failed enum ContactPointGeneration to_i8"))?;
5536            __serializer.serialize_bits(&num)?;
5537            __serializer.end()
5538        }
5539    }
5540};
5541const _: () = {
5542    use havok_serde as __serde;
5543    impl __serde::Serialize for BroadPhaseBorderBehaviour {
5544        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
5545        where
5546            S: __serde::ser::Serializer,
5547        {
5548            let mut __serializer = __serializer.serialize_enum_flags()?;
5549            match self {
5550                Self::BROADPHASE_BORDER_ASSERT => {
5551                    __serializer.serialize_field("BROADPHASE_BORDER_ASSERT", &0u64)
5552                }
5553                Self::BROADPHASE_BORDER_FIX_ENTITY => {
5554                    __serializer.serialize_field("BROADPHASE_BORDER_FIX_ENTITY", &1u64)
5555                }
5556                Self::BROADPHASE_BORDER_REMOVE_ENTITY => {
5557                    __serializer
5558                        .serialize_field("BROADPHASE_BORDER_REMOVE_ENTITY", &2u64)
5559                }
5560                Self::BROADPHASE_BORDER_DO_NOTHING => {
5561                    __serializer.serialize_field("BROADPHASE_BORDER_DO_NOTHING", &3u64)
5562                }
5563            }?;
5564            use num_traits::ToPrimitive as _;
5565            let num = self
5566                .to_i8()
5567                .ok_or(S::Error::custom("Failed enum BroadPhaseBorderBehaviour to_i8"))?;
5568            __serializer.serialize_bits(&num)?;
5569            __serializer.end()
5570        }
5571    }
5572};
5573const _: () = {
5574    use havok_serde as __serde;
5575    impl __serde::Serialize for TreeUpdateType {
5576        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
5577        where
5578            S: __serde::ser::Serializer,
5579        {
5580            let mut __serializer = __serializer.serialize_enum_flags()?;
5581            match self {
5582                Self::REBUILD_ACTIVE => {
5583                    __serializer.serialize_field("REBUILD_ACTIVE", &0u64)
5584                }
5585                Self::REBUILD_ALL => __serializer.serialize_field("REBUILD_ALL", &1u64),
5586            }?;
5587            use num_traits::ToPrimitive as _;
5588            let num = self
5589                .to_i8()
5590                .ok_or(S::Error::custom("Failed enum TreeUpdateType to_i8"))?;
5591            __serializer.serialize_bits(&num)?;
5592            __serializer.end()
5593        }
5594    }
5595};
5596#[doc(hidden)]
5597#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
5598const _: () = {
5599    #[allow(unused_extern_crates, clippy::useless_attribute)]
5600    extern crate havok_serde as _serde;
5601    #[automatically_derived]
5602    impl<'de> _serde::Deserialize<'de> for SimulationType {
5603        fn deserialize<__D>(
5604            __deserializer: __D,
5605        ) -> _serde::__private::Result<Self, __D::Error>
5606        where
5607            __D: _serde::Deserializer<'de>,
5608        {
5609            #[allow(non_camel_case_types)]
5610            #[doc(hidden)]
5611            enum __Field {
5612                __field0,
5613                __field1,
5614                __field2,
5615                __field3,
5616            }
5617            #[doc(hidden)]
5618            struct __FieldVisitor;
5619            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
5620                type Value = __Field;
5621                fn expecting(
5622                    &self,
5623                    __formatter: &mut _serde::__private::Formatter,
5624                ) -> _serde::__private::fmt::Result {
5625                    _serde::__private::Formatter::write_str(
5626                        __formatter,
5627                        "variant identifier",
5628                    )
5629                }
5630                fn visit_int8<__E>(
5631                    self,
5632                    __value: i8,
5633                ) -> _serde::__private::Result<Self::Value, __E>
5634                where
5635                    __E: _serde::de::Error,
5636                {
5637                    match __value {
5638                        0i8 => _serde::__private::Ok(__Field::__field0),
5639                        1i8 => _serde::__private::Ok(__Field::__field1),
5640                        2i8 => _serde::__private::Ok(__Field::__field2),
5641                        3i8 => _serde::__private::Ok(__Field::__field3),
5642                        _ => {
5643                            _serde::__private::Err(
5644                                _serde::de::Error::invalid_value(
5645                                    _serde::de::Unexpected::Int8(__value),
5646                                    &"value(i8) of variant is one of 0, 1, 2, 3",
5647                                ),
5648                            )
5649                        }
5650                    }
5651                }
5652                fn visit_stringptr<__E>(
5653                    self,
5654                    __value: StringPtr<'de>,
5655                ) -> _serde::__private::Result<Self::Value, __E>
5656                where
5657                    __E: _serde::de::Error,
5658                {
5659                    if let Some(__value) = __value.into_inner() {
5660                        match __value.as_ref() {
5661                            v if v == "0"
5662                                || v.eq_ignore_ascii_case("SIMULATION_TYPE_INVALID") => {
5663                                _serde::__private::Ok(__Field::__field0)
5664                            }
5665                            v if v == "1"
5666                                || v.eq_ignore_ascii_case("SIMULATION_TYPE_DISCRETE") => {
5667                                _serde::__private::Ok(__Field::__field1)
5668                            }
5669                            v if v == "2"
5670                                || v.eq_ignore_ascii_case("SIMULATION_TYPE_CONTINUOUS") => {
5671                                _serde::__private::Ok(__Field::__field2)
5672                            }
5673                            v if v == "3"
5674                                || v
5675                                    .eq_ignore_ascii_case("SIMULATION_TYPE_MULTITHREADED") => {
5676                                _serde::__private::Ok(__Field::__field3)
5677                            }
5678                            _ => {
5679                                _serde::__private::Err(
5680                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
5681                                )
5682                            }
5683                        }
5684                    } else {
5685                        _serde::__private::Err(
5686                            _serde::de::Error::unknown_variant("None", VARIANTS),
5687                        )
5688                    }
5689                }
5690            }
5691            impl<'de> _serde::Deserialize<'de> for __Field {
5692                #[inline]
5693                fn deserialize<__D>(
5694                    __deserializer: __D,
5695                ) -> _serde::__private::Result<Self, __D::Error>
5696                where
5697                    __D: _serde::Deserializer<'de>,
5698                {
5699                    _serde::Deserializer::deserialize_identifier(
5700                        __deserializer,
5701                        _serde::de::ReadEnumSize::Int8,
5702                        __FieldVisitor,
5703                    )
5704                }
5705            }
5706            #[doc(hidden)]
5707            struct __Visitor<'de> {
5708                marker: _serde::__private::PhantomData<SimulationType>,
5709                lifetime: _serde::__private::PhantomData<&'de ()>,
5710            }
5711            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
5712                type Value = SimulationType;
5713                fn expecting(
5714                    &self,
5715                    __formatter: &mut _serde::__private::Formatter,
5716                ) -> _serde::__private::fmt::Result {
5717                    _serde::__private::Formatter::write_str(
5718                        __formatter,
5719                        "enum SimulationType",
5720                    )
5721                }
5722                fn visit_enum<__A>(
5723                    self,
5724                    __data: __A,
5725                ) -> _serde::__private::Result<Self::Value, __A::Error>
5726                where
5727                    __A: _serde::de::EnumAccess<'de>,
5728                {
5729                    match _serde::de::EnumAccess::variant(__data)? {
5730                        (__Field::__field0, __variant) => {
5731                            _serde::de::VariantAccess::unit_variant(__variant)?;
5732                            _serde::__private::Ok(
5733                                SimulationType::SIMULATION_TYPE_INVALID,
5734                            )
5735                        }
5736                        (__Field::__field1, __variant) => {
5737                            _serde::de::VariantAccess::unit_variant(__variant)?;
5738                            _serde::__private::Ok(
5739                                SimulationType::SIMULATION_TYPE_DISCRETE,
5740                            )
5741                        }
5742                        (__Field::__field2, __variant) => {
5743                            _serde::de::VariantAccess::unit_variant(__variant)?;
5744                            _serde::__private::Ok(
5745                                SimulationType::SIMULATION_TYPE_CONTINUOUS,
5746                            )
5747                        }
5748                        (__Field::__field3, __variant) => {
5749                            _serde::de::VariantAccess::unit_variant(__variant)?;
5750                            _serde::__private::Ok(
5751                                SimulationType::SIMULATION_TYPE_MULTITHREADED,
5752                            )
5753                        }
5754                    }
5755                }
5756            }
5757            #[doc(hidden)]
5758            const VARIANTS: &'static [&'static str] = &[
5759                "SIMULATION_TYPE_INVALID",
5760                "SIMULATION_TYPE_DISCRETE",
5761                "SIMULATION_TYPE_CONTINUOUS",
5762                "SIMULATION_TYPE_MULTITHREADED",
5763            ];
5764            _serde::Deserializer::deserialize_enum(
5765                __deserializer,
5766                "SimulationType",
5767                VARIANTS,
5768                __Visitor {
5769                    marker: _serde::__private::PhantomData::<SimulationType>,
5770                    lifetime: _serde::__private::PhantomData,
5771                },
5772            )
5773        }
5774    }
5775};
5776#[doc(hidden)]
5777#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
5778const _: () = {
5779    #[allow(unused_extern_crates, clippy::useless_attribute)]
5780    extern crate havok_serde as _serde;
5781    #[automatically_derived]
5782    impl<'de> _serde::Deserialize<'de> for ContactPointGeneration {
5783        fn deserialize<__D>(
5784            __deserializer: __D,
5785        ) -> _serde::__private::Result<Self, __D::Error>
5786        where
5787            __D: _serde::Deserializer<'de>,
5788        {
5789            #[allow(non_camel_case_types)]
5790            #[doc(hidden)]
5791            enum __Field {
5792                __field0,
5793                __field1,
5794                __field2,
5795            }
5796            #[doc(hidden)]
5797            struct __FieldVisitor;
5798            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
5799                type Value = __Field;
5800                fn expecting(
5801                    &self,
5802                    __formatter: &mut _serde::__private::Formatter,
5803                ) -> _serde::__private::fmt::Result {
5804                    _serde::__private::Formatter::write_str(
5805                        __formatter,
5806                        "variant identifier",
5807                    )
5808                }
5809                fn visit_int8<__E>(
5810                    self,
5811                    __value: i8,
5812                ) -> _serde::__private::Result<Self::Value, __E>
5813                where
5814                    __E: _serde::de::Error,
5815                {
5816                    match __value {
5817                        0i8 => _serde::__private::Ok(__Field::__field0),
5818                        1i8 => _serde::__private::Ok(__Field::__field1),
5819                        2i8 => _serde::__private::Ok(__Field::__field2),
5820                        _ => {
5821                            _serde::__private::Err(
5822                                _serde::de::Error::invalid_value(
5823                                    _serde::de::Unexpected::Int8(__value),
5824                                    &"value(i8) of variant is one of 0, 1, 2",
5825                                ),
5826                            )
5827                        }
5828                    }
5829                }
5830                fn visit_stringptr<__E>(
5831                    self,
5832                    __value: StringPtr<'de>,
5833                ) -> _serde::__private::Result<Self::Value, __E>
5834                where
5835                    __E: _serde::de::Error,
5836                {
5837                    if let Some(__value) = __value.into_inner() {
5838                        match __value.as_ref() {
5839                            v if v == "0"
5840                                || v.eq_ignore_ascii_case("CONTACT_POINT_ACCEPT_ALWAYS") => {
5841                                _serde::__private::Ok(__Field::__field0)
5842                            }
5843                            v if v == "1"
5844                                || v
5845                                    .eq_ignore_ascii_case("CONTACT_POINT_REJECT_DUBIOUS") => {
5846                                _serde::__private::Ok(__Field::__field1)
5847                            }
5848                            v if v == "2"
5849                                || v.eq_ignore_ascii_case("CONTACT_POINT_REJECT_MANY") => {
5850                                _serde::__private::Ok(__Field::__field2)
5851                            }
5852                            _ => {
5853                                _serde::__private::Err(
5854                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
5855                                )
5856                            }
5857                        }
5858                    } else {
5859                        _serde::__private::Err(
5860                            _serde::de::Error::unknown_variant("None", VARIANTS),
5861                        )
5862                    }
5863                }
5864            }
5865            impl<'de> _serde::Deserialize<'de> for __Field {
5866                #[inline]
5867                fn deserialize<__D>(
5868                    __deserializer: __D,
5869                ) -> _serde::__private::Result<Self, __D::Error>
5870                where
5871                    __D: _serde::Deserializer<'de>,
5872                {
5873                    _serde::Deserializer::deserialize_identifier(
5874                        __deserializer,
5875                        _serde::de::ReadEnumSize::Int8,
5876                        __FieldVisitor,
5877                    )
5878                }
5879            }
5880            #[doc(hidden)]
5881            struct __Visitor<'de> {
5882                marker: _serde::__private::PhantomData<ContactPointGeneration>,
5883                lifetime: _serde::__private::PhantomData<&'de ()>,
5884            }
5885            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
5886                type Value = ContactPointGeneration;
5887                fn expecting(
5888                    &self,
5889                    __formatter: &mut _serde::__private::Formatter,
5890                ) -> _serde::__private::fmt::Result {
5891                    _serde::__private::Formatter::write_str(
5892                        __formatter,
5893                        "enum ContactPointGeneration",
5894                    )
5895                }
5896                fn visit_enum<__A>(
5897                    self,
5898                    __data: __A,
5899                ) -> _serde::__private::Result<Self::Value, __A::Error>
5900                where
5901                    __A: _serde::de::EnumAccess<'de>,
5902                {
5903                    match _serde::de::EnumAccess::variant(__data)? {
5904                        (__Field::__field0, __variant) => {
5905                            _serde::de::VariantAccess::unit_variant(__variant)?;
5906                            _serde::__private::Ok(
5907                                ContactPointGeneration::CONTACT_POINT_ACCEPT_ALWAYS,
5908                            )
5909                        }
5910                        (__Field::__field1, __variant) => {
5911                            _serde::de::VariantAccess::unit_variant(__variant)?;
5912                            _serde::__private::Ok(
5913                                ContactPointGeneration::CONTACT_POINT_REJECT_DUBIOUS,
5914                            )
5915                        }
5916                        (__Field::__field2, __variant) => {
5917                            _serde::de::VariantAccess::unit_variant(__variant)?;
5918                            _serde::__private::Ok(
5919                                ContactPointGeneration::CONTACT_POINT_REJECT_MANY,
5920                            )
5921                        }
5922                    }
5923                }
5924            }
5925            #[doc(hidden)]
5926            const VARIANTS: &'static [&'static str] = &[
5927                "CONTACT_POINT_ACCEPT_ALWAYS",
5928                "CONTACT_POINT_REJECT_DUBIOUS",
5929                "CONTACT_POINT_REJECT_MANY",
5930            ];
5931            _serde::Deserializer::deserialize_enum(
5932                __deserializer,
5933                "ContactPointGeneration",
5934                VARIANTS,
5935                __Visitor {
5936                    marker: _serde::__private::PhantomData::<ContactPointGeneration>,
5937                    lifetime: _serde::__private::PhantomData,
5938                },
5939            )
5940        }
5941    }
5942};
5943#[doc(hidden)]
5944#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
5945const _: () = {
5946    #[allow(unused_extern_crates, clippy::useless_attribute)]
5947    extern crate havok_serde as _serde;
5948    #[automatically_derived]
5949    impl<'de> _serde::Deserialize<'de> for BroadPhaseBorderBehaviour {
5950        fn deserialize<__D>(
5951            __deserializer: __D,
5952        ) -> _serde::__private::Result<Self, __D::Error>
5953        where
5954            __D: _serde::Deserializer<'de>,
5955        {
5956            #[allow(non_camel_case_types)]
5957            #[doc(hidden)]
5958            enum __Field {
5959                __field0,
5960                __field1,
5961                __field2,
5962                __field3,
5963            }
5964            #[doc(hidden)]
5965            struct __FieldVisitor;
5966            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
5967                type Value = __Field;
5968                fn expecting(
5969                    &self,
5970                    __formatter: &mut _serde::__private::Formatter,
5971                ) -> _serde::__private::fmt::Result {
5972                    _serde::__private::Formatter::write_str(
5973                        __formatter,
5974                        "variant identifier",
5975                    )
5976                }
5977                fn visit_int8<__E>(
5978                    self,
5979                    __value: i8,
5980                ) -> _serde::__private::Result<Self::Value, __E>
5981                where
5982                    __E: _serde::de::Error,
5983                {
5984                    match __value {
5985                        0i8 => _serde::__private::Ok(__Field::__field0),
5986                        1i8 => _serde::__private::Ok(__Field::__field1),
5987                        2i8 => _serde::__private::Ok(__Field::__field2),
5988                        3i8 => _serde::__private::Ok(__Field::__field3),
5989                        _ => {
5990                            _serde::__private::Err(
5991                                _serde::de::Error::invalid_value(
5992                                    _serde::de::Unexpected::Int8(__value),
5993                                    &"value(i8) of variant is one of 0, 1, 2, 3",
5994                                ),
5995                            )
5996                        }
5997                    }
5998                }
5999                fn visit_stringptr<__E>(
6000                    self,
6001                    __value: StringPtr<'de>,
6002                ) -> _serde::__private::Result<Self::Value, __E>
6003                where
6004                    __E: _serde::de::Error,
6005                {
6006                    if let Some(__value) = __value.into_inner() {
6007                        match __value.as_ref() {
6008                            v if v == "0"
6009                                || v.eq_ignore_ascii_case("BROADPHASE_BORDER_ASSERT") => {
6010                                _serde::__private::Ok(__Field::__field0)
6011                            }
6012                            v if v == "1"
6013                                || v
6014                                    .eq_ignore_ascii_case("BROADPHASE_BORDER_FIX_ENTITY") => {
6015                                _serde::__private::Ok(__Field::__field1)
6016                            }
6017                            v if v == "2"
6018                                || v
6019                                    .eq_ignore_ascii_case("BROADPHASE_BORDER_REMOVE_ENTITY") => {
6020                                _serde::__private::Ok(__Field::__field2)
6021                            }
6022                            v if v == "3"
6023                                || v
6024                                    .eq_ignore_ascii_case("BROADPHASE_BORDER_DO_NOTHING") => {
6025                                _serde::__private::Ok(__Field::__field3)
6026                            }
6027                            _ => {
6028                                _serde::__private::Err(
6029                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
6030                                )
6031                            }
6032                        }
6033                    } else {
6034                        _serde::__private::Err(
6035                            _serde::de::Error::unknown_variant("None", VARIANTS),
6036                        )
6037                    }
6038                }
6039            }
6040            impl<'de> _serde::Deserialize<'de> for __Field {
6041                #[inline]
6042                fn deserialize<__D>(
6043                    __deserializer: __D,
6044                ) -> _serde::__private::Result<Self, __D::Error>
6045                where
6046                    __D: _serde::Deserializer<'de>,
6047                {
6048                    _serde::Deserializer::deserialize_identifier(
6049                        __deserializer,
6050                        _serde::de::ReadEnumSize::Int8,
6051                        __FieldVisitor,
6052                    )
6053                }
6054            }
6055            #[doc(hidden)]
6056            struct __Visitor<'de> {
6057                marker: _serde::__private::PhantomData<BroadPhaseBorderBehaviour>,
6058                lifetime: _serde::__private::PhantomData<&'de ()>,
6059            }
6060            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
6061                type Value = BroadPhaseBorderBehaviour;
6062                fn expecting(
6063                    &self,
6064                    __formatter: &mut _serde::__private::Formatter,
6065                ) -> _serde::__private::fmt::Result {
6066                    _serde::__private::Formatter::write_str(
6067                        __formatter,
6068                        "enum BroadPhaseBorderBehaviour",
6069                    )
6070                }
6071                fn visit_enum<__A>(
6072                    self,
6073                    __data: __A,
6074                ) -> _serde::__private::Result<Self::Value, __A::Error>
6075                where
6076                    __A: _serde::de::EnumAccess<'de>,
6077                {
6078                    match _serde::de::EnumAccess::variant(__data)? {
6079                        (__Field::__field0, __variant) => {
6080                            _serde::de::VariantAccess::unit_variant(__variant)?;
6081                            _serde::__private::Ok(
6082                                BroadPhaseBorderBehaviour::BROADPHASE_BORDER_ASSERT,
6083                            )
6084                        }
6085                        (__Field::__field1, __variant) => {
6086                            _serde::de::VariantAccess::unit_variant(__variant)?;
6087                            _serde::__private::Ok(
6088                                BroadPhaseBorderBehaviour::BROADPHASE_BORDER_FIX_ENTITY,
6089                            )
6090                        }
6091                        (__Field::__field2, __variant) => {
6092                            _serde::de::VariantAccess::unit_variant(__variant)?;
6093                            _serde::__private::Ok(
6094                                BroadPhaseBorderBehaviour::BROADPHASE_BORDER_REMOVE_ENTITY,
6095                            )
6096                        }
6097                        (__Field::__field3, __variant) => {
6098                            _serde::de::VariantAccess::unit_variant(__variant)?;
6099                            _serde::__private::Ok(
6100                                BroadPhaseBorderBehaviour::BROADPHASE_BORDER_DO_NOTHING,
6101                            )
6102                        }
6103                    }
6104                }
6105            }
6106            #[doc(hidden)]
6107            const VARIANTS: &'static [&'static str] = &[
6108                "BROADPHASE_BORDER_ASSERT",
6109                "BROADPHASE_BORDER_FIX_ENTITY",
6110                "BROADPHASE_BORDER_REMOVE_ENTITY",
6111                "BROADPHASE_BORDER_DO_NOTHING",
6112            ];
6113            _serde::Deserializer::deserialize_enum(
6114                __deserializer,
6115                "BroadPhaseBorderBehaviour",
6116                VARIANTS,
6117                __Visitor {
6118                    marker: _serde::__private::PhantomData::<BroadPhaseBorderBehaviour>,
6119                    lifetime: _serde::__private::PhantomData,
6120                },
6121            )
6122        }
6123    }
6124};
6125#[doc(hidden)]
6126#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
6127const _: () = {
6128    #[allow(unused_extern_crates, clippy::useless_attribute)]
6129    extern crate havok_serde as _serde;
6130    #[automatically_derived]
6131    impl<'de> _serde::Deserialize<'de> for TreeUpdateType {
6132        fn deserialize<__D>(
6133            __deserializer: __D,
6134        ) -> _serde::__private::Result<Self, __D::Error>
6135        where
6136            __D: _serde::Deserializer<'de>,
6137        {
6138            #[allow(non_camel_case_types)]
6139            #[doc(hidden)]
6140            enum __Field {
6141                __field0,
6142                __field1,
6143            }
6144            #[doc(hidden)]
6145            struct __FieldVisitor;
6146            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
6147                type Value = __Field;
6148                fn expecting(
6149                    &self,
6150                    __formatter: &mut _serde::__private::Formatter,
6151                ) -> _serde::__private::fmt::Result {
6152                    _serde::__private::Formatter::write_str(
6153                        __formatter,
6154                        "variant identifier",
6155                    )
6156                }
6157                fn visit_int8<__E>(
6158                    self,
6159                    __value: i8,
6160                ) -> _serde::__private::Result<Self::Value, __E>
6161                where
6162                    __E: _serde::de::Error,
6163                {
6164                    match __value {
6165                        0i8 => _serde::__private::Ok(__Field::__field0),
6166                        1i8 => _serde::__private::Ok(__Field::__field1),
6167                        _ => {
6168                            _serde::__private::Err(
6169                                _serde::de::Error::invalid_value(
6170                                    _serde::de::Unexpected::Int8(__value),
6171                                    &"value(i8) of variant is one of 0, 1",
6172                                ),
6173                            )
6174                        }
6175                    }
6176                }
6177                fn visit_stringptr<__E>(
6178                    self,
6179                    __value: StringPtr<'de>,
6180                ) -> _serde::__private::Result<Self::Value, __E>
6181                where
6182                    __E: _serde::de::Error,
6183                {
6184                    if let Some(__value) = __value.into_inner() {
6185                        match __value.as_ref() {
6186                            v if v == "0" || v.eq_ignore_ascii_case("REBUILD_ACTIVE") => {
6187                                _serde::__private::Ok(__Field::__field0)
6188                            }
6189                            v if v == "1" || v.eq_ignore_ascii_case("REBUILD_ALL") => {
6190                                _serde::__private::Ok(__Field::__field1)
6191                            }
6192                            _ => {
6193                                _serde::__private::Err(
6194                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
6195                                )
6196                            }
6197                        }
6198                    } else {
6199                        _serde::__private::Err(
6200                            _serde::de::Error::unknown_variant("None", VARIANTS),
6201                        )
6202                    }
6203                }
6204            }
6205            impl<'de> _serde::Deserialize<'de> for __Field {
6206                #[inline]
6207                fn deserialize<__D>(
6208                    __deserializer: __D,
6209                ) -> _serde::__private::Result<Self, __D::Error>
6210                where
6211                    __D: _serde::Deserializer<'de>,
6212                {
6213                    _serde::Deserializer::deserialize_identifier(
6214                        __deserializer,
6215                        _serde::de::ReadEnumSize::Int8,
6216                        __FieldVisitor,
6217                    )
6218                }
6219            }
6220            #[doc(hidden)]
6221            struct __Visitor<'de> {
6222                marker: _serde::__private::PhantomData<TreeUpdateType>,
6223                lifetime: _serde::__private::PhantomData<&'de ()>,
6224            }
6225            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
6226                type Value = TreeUpdateType;
6227                fn expecting(
6228                    &self,
6229                    __formatter: &mut _serde::__private::Formatter,
6230                ) -> _serde::__private::fmt::Result {
6231                    _serde::__private::Formatter::write_str(
6232                        __formatter,
6233                        "enum TreeUpdateType",
6234                    )
6235                }
6236                fn visit_enum<__A>(
6237                    self,
6238                    __data: __A,
6239                ) -> _serde::__private::Result<Self::Value, __A::Error>
6240                where
6241                    __A: _serde::de::EnumAccess<'de>,
6242                {
6243                    match _serde::de::EnumAccess::variant(__data)? {
6244                        (__Field::__field0, __variant) => {
6245                            _serde::de::VariantAccess::unit_variant(__variant)?;
6246                            _serde::__private::Ok(TreeUpdateType::REBUILD_ACTIVE)
6247                        }
6248                        (__Field::__field1, __variant) => {
6249                            _serde::de::VariantAccess::unit_variant(__variant)?;
6250                            _serde::__private::Ok(TreeUpdateType::REBUILD_ALL)
6251                        }
6252                    }
6253                }
6254            }
6255            #[doc(hidden)]
6256            const VARIANTS: &'static [&'static str] = &["REBUILD_ACTIVE", "REBUILD_ALL"];
6257            _serde::Deserializer::deserialize_enum(
6258                __deserializer,
6259                "TreeUpdateType",
6260                VARIANTS,
6261                __Visitor {
6262                    marker: _serde::__private::PhantomData::<TreeUpdateType>,
6263                    lifetime: _serde::__private::PhantomData,
6264                },
6265            )
6266        }
6267    }
6268};