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