havok_classes/generated/
hkpWorld_.rs

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

havok_classes/generated/
hkpWorld_.rs
