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 hkpRagdollConstraintDataAtoms {
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(rename = "transforms"))]
31 #[cfg_attr(feature = "serde", serde(rename = "transforms"))]
32 pub m_transforms: hkpSetLocalTransformsConstraintAtom,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "setupStabilization"))]
38 #[cfg_attr(feature = "serde", serde(rename = "setupStabilization"))]
39 pub m_setupStabilization: hkpSetupStabilizationAtom,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "ragdollMotors"))]
45 #[cfg_attr(feature = "serde", serde(rename = "ragdollMotors"))]
46 pub m_ragdollMotors: hkpRagdollMotorConstraintAtom,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "angFriction"))]
52 #[cfg_attr(feature = "serde", serde(rename = "angFriction"))]
53 pub m_angFriction: hkpAngFrictionConstraintAtom,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "twistLimit"))]
59 #[cfg_attr(feature = "serde", serde(rename = "twistLimit"))]
60 pub m_twistLimit: hkpTwistLimitConstraintAtom,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "coneLimit"))]
66 #[cfg_attr(feature = "serde", serde(rename = "coneLimit"))]
67 pub m_coneLimit: hkpConeLimitConstraintAtom,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "planesLimit"))]
73 #[cfg_attr(feature = "serde", serde(rename = "planesLimit"))]
74 pub m_planesLimit: hkpConeLimitConstraintAtom,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "ballSocket"))]
80 #[cfg_attr(feature = "serde", serde(rename = "ballSocket"))]
81 pub m_ballSocket: hkpBallSocketConstraintAtom,
82}
83const _: () = {
84 use havok_serde as _serde;
85 impl _serde::HavokClass for hkpRagdollConstraintDataAtoms {
86 #[inline]
87 fn name(&self) -> &'static str {
88 "hkpRagdollConstraintDataAtoms"
89 }
90 #[inline]
91 fn signature(&self) -> _serde::__private::Signature {
92 _serde::__private::Signature::new(0xeed76b00)
93 }
94 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
95 fn deps_indexes(&self) -> Vec<usize> {
96 let mut v = Vec::new();
97 v.extend(self.m_transforms.deps_indexes());
98 v.extend(self.m_setupStabilization.deps_indexes());
99 v.extend(self.m_ragdollMotors.deps_indexes());
100 v.extend(self.m_angFriction.deps_indexes());
101 v.extend(self.m_twistLimit.deps_indexes());
102 v.extend(self.m_coneLimit.deps_indexes());
103 v.extend(self.m_planesLimit.deps_indexes());
104 v.extend(self.m_ballSocket.deps_indexes());
105 v
106 }
107 }
108 impl _serde::Serialize for hkpRagdollConstraintDataAtoms {
109 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
110 where
111 S: _serde::ser::Serializer,
112 {
113 let class_meta = self
114 .__ptr
115 .map(|name| (name, _serde::__private::Signature::new(0xeed76b00)));
116 let mut serializer = __serializer
117 .serialize_struct(
118 "hkpRagdollConstraintDataAtoms",
119 class_meta,
120 (336u64, 352u64),
121 )?;
122 serializer.serialize_field("transforms", &self.m_transforms)?;
123 serializer
124 .serialize_field("setupStabilization", &self.m_setupStabilization)?;
125 serializer.serialize_field("ragdollMotors", &self.m_ragdollMotors)?;
126 serializer.serialize_field("angFriction", &self.m_angFriction)?;
127 serializer.serialize_field("twistLimit", &self.m_twistLimit)?;
128 serializer.serialize_field("coneLimit", &self.m_coneLimit)?;
129 serializer.serialize_field("planesLimit", &self.m_planesLimit)?;
130 serializer.serialize_field("ballSocket", &self.m_ballSocket)?;
131 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
132 serializer.end()
133 }
134 }
135};
136#[doc(hidden)]
137#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
138const _: () = {
139 use havok_serde as _serde;
140 #[automatically_derived]
141 impl<'de> _serde::Deserialize<'de> for hkpRagdollConstraintDataAtoms {
142 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
143 where
144 __D: _serde::Deserializer<'de>,
145 {
146 #[allow(non_camel_case_types)]
147 enum __Field {
148 m_transforms,
149 m_setupStabilization,
150 m_ragdollMotors,
151 m_angFriction,
152 m_twistLimit,
153 m_coneLimit,
154 m_planesLimit,
155 m_ballSocket,
156 __ignore,
157 }
158 struct __FieldVisitor;
159 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
160 type Value = __Field;
161 fn expecting(
162 &self,
163 __formatter: &mut core::fmt::Formatter,
164 ) -> core::fmt::Result {
165 core::fmt::Formatter::write_str(__formatter, "field identifier")
166 }
167 #[allow(clippy::match_single_binding)]
169 #[allow(clippy::reversed_empty_ranges)]
170 #[allow(clippy::single_match)]
171 fn visit_key<__E>(
172 self,
173 __value: &str,
174 ) -> core::result::Result<Self::Value, __E>
175 where
176 __E: _serde::de::Error,
177 {
178 match __value {
179 "transforms" => Ok(__Field::m_transforms),
180 "setupStabilization" => Ok(__Field::m_setupStabilization),
181 "ragdollMotors" => Ok(__Field::m_ragdollMotors),
182 "angFriction" => Ok(__Field::m_angFriction),
183 "twistLimit" => Ok(__Field::m_twistLimit),
184 "coneLimit" => Ok(__Field::m_coneLimit),
185 "planesLimit" => Ok(__Field::m_planesLimit),
186 "ballSocket" => Ok(__Field::m_ballSocket),
187 _ => Ok(__Field::__ignore),
188 }
189 }
190 }
191 impl<'de> _serde::Deserialize<'de> for __Field {
192 #[inline]
193 fn deserialize<__D>(
194 __deserializer: __D,
195 ) -> core::result::Result<Self, __D::Error>
196 where
197 __D: _serde::Deserializer<'de>,
198 {
199 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
200 }
201 }
202 struct __hkpRagdollConstraintDataAtomsVisitor<'de> {
203 marker: _serde::__private::PhantomData<hkpRagdollConstraintDataAtoms>,
204 lifetime: _serde::__private::PhantomData<&'de ()>,
205 }
206 #[allow(clippy::match_single_binding)]
207 #[allow(clippy::reversed_empty_ranges)]
208 #[allow(clippy::single_match)]
209 impl<'de> _serde::de::Visitor<'de>
210 for __hkpRagdollConstraintDataAtomsVisitor<'de> {
211 type Value = hkpRagdollConstraintDataAtoms;
212 fn expecting(
213 &self,
214 __formatter: &mut core::fmt::Formatter,
215 ) -> core::fmt::Result {
216 core::fmt::Formatter::write_str(
217 __formatter,
218 "struct hkpRagdollConstraintDataAtoms",
219 )
220 }
221 fn visit_struct_for_bytes<__A>(
222 self,
223 mut __map: __A,
224 ) -> _serde::__private::Result<Self::Value, __A::Error>
225 where
226 __A: _serde::de::MapAccess<'de>,
227 {
228 let __ptr = __A::class_ptr(&mut __map);
229 let mut m_transforms: _serde::__private::Option<
230 hkpSetLocalTransformsConstraintAtom,
231 > = _serde::__private::None;
232 let mut m_setupStabilization: _serde::__private::Option<
233 hkpSetupStabilizationAtom,
234 > = _serde::__private::None;
235 let mut m_ragdollMotors: _serde::__private::Option<
236 hkpRagdollMotorConstraintAtom,
237 > = _serde::__private::None;
238 let mut m_angFriction: _serde::__private::Option<
239 hkpAngFrictionConstraintAtom,
240 > = _serde::__private::None;
241 let mut m_twistLimit: _serde::__private::Option<
242 hkpTwistLimitConstraintAtom,
243 > = _serde::__private::None;
244 let mut m_coneLimit: _serde::__private::Option<
245 hkpConeLimitConstraintAtom,
246 > = _serde::__private::None;
247 let mut m_planesLimit: _serde::__private::Option<
248 hkpConeLimitConstraintAtom,
249 > = _serde::__private::None;
250 let mut m_ballSocket: _serde::__private::Option<
251 hkpBallSocketConstraintAtom,
252 > = _serde::__private::None;
253 for i in 0..8usize {
254 match i {
255 0usize => {
256 if _serde::__private::Option::is_some(&m_transforms) {
257 return _serde::__private::Err(
258 <__A::Error as _serde::de::Error>::duplicate_field(
259 "transforms",
260 ),
261 );
262 }
263 m_transforms = _serde::__private::Some(
264 match __A::next_value::<
265 hkpSetLocalTransformsConstraintAtom,
266 >(&mut __map) {
267 _serde::__private::Ok(__val) => __val,
268 _serde::__private::Err(__err) => {
269 return _serde::__private::Err(__err);
270 }
271 },
272 );
273 }
274 1usize => {
275 if _serde::__private::Option::is_some(
276 &m_setupStabilization,
277 ) {
278 return _serde::__private::Err(
279 <__A::Error as _serde::de::Error>::duplicate_field(
280 "setupStabilization",
281 ),
282 );
283 }
284 m_setupStabilization = _serde::__private::Some(
285 match __A::next_value::<
286 hkpSetupStabilizationAtom,
287 >(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 2usize => {
296 if _serde::__private::Option::is_some(&m_ragdollMotors) {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "ragdollMotors",
300 ),
301 );
302 }
303 m_ragdollMotors = _serde::__private::Some(
304 match __A::next_value::<
305 hkpRagdollMotorConstraintAtom,
306 >(&mut __map) {
307 _serde::__private::Ok(__val) => __val,
308 _serde::__private::Err(__err) => {
309 return _serde::__private::Err(__err);
310 }
311 },
312 );
313 }
314 3usize => {
315 if _serde::__private::Option::is_some(&m_angFriction) {
316 return _serde::__private::Err(
317 <__A::Error as _serde::de::Error>::duplicate_field(
318 "angFriction",
319 ),
320 );
321 }
322 m_angFriction = _serde::__private::Some(
323 match __A::next_value::<
324 hkpAngFrictionConstraintAtom,
325 >(&mut __map) {
326 _serde::__private::Ok(__val) => __val,
327 _serde::__private::Err(__err) => {
328 return _serde::__private::Err(__err);
329 }
330 },
331 );
332 }
333 4usize => {
334 if _serde::__private::Option::is_some(&m_twistLimit) {
335 return _serde::__private::Err(
336 <__A::Error as _serde::de::Error>::duplicate_field(
337 "twistLimit",
338 ),
339 );
340 }
341 m_twistLimit = _serde::__private::Some(
342 match __A::next_value::<
343 hkpTwistLimitConstraintAtom,
344 >(&mut __map) {
345 _serde::__private::Ok(__val) => __val,
346 _serde::__private::Err(__err) => {
347 return _serde::__private::Err(__err);
348 }
349 },
350 );
351 }
352 5usize => {
353 if _serde::__private::Option::is_some(&m_coneLimit) {
354 return _serde::__private::Err(
355 <__A::Error as _serde::de::Error>::duplicate_field(
356 "coneLimit",
357 ),
358 );
359 }
360 m_coneLimit = _serde::__private::Some(
361 match __A::next_value::<
362 hkpConeLimitConstraintAtom,
363 >(&mut __map) {
364 _serde::__private::Ok(__val) => __val,
365 _serde::__private::Err(__err) => {
366 return _serde::__private::Err(__err);
367 }
368 },
369 );
370 }
371 6usize => {
372 if _serde::__private::Option::is_some(&m_planesLimit) {
373 return _serde::__private::Err(
374 <__A::Error as _serde::de::Error>::duplicate_field(
375 "planesLimit",
376 ),
377 );
378 }
379 m_planesLimit = _serde::__private::Some(
380 match __A::next_value::<
381 hkpConeLimitConstraintAtom,
382 >(&mut __map) {
383 _serde::__private::Ok(__val) => __val,
384 _serde::__private::Err(__err) => {
385 return _serde::__private::Err(__err);
386 }
387 },
388 );
389 }
390 7usize => {
391 if _serde::__private::Option::is_some(&m_ballSocket) {
392 return _serde::__private::Err(
393 <__A::Error as _serde::de::Error>::duplicate_field(
394 "ballSocket",
395 ),
396 );
397 }
398 m_ballSocket = _serde::__private::Some(
399 match __A::next_value::<
400 hkpBallSocketConstraintAtom,
401 >(&mut __map) {
402 _serde::__private::Ok(__val) => __val,
403 _serde::__private::Err(__err) => {
404 return _serde::__private::Err(__err);
405 }
406 },
407 );
408 }
409 _ => {}
410 }
411 }
412 __A::pad(&mut __map, 8usize, 8usize)?;
413 let m_transforms = match m_transforms {
414 _serde::__private::Some(__field) => __field,
415 _serde::__private::None => {
416 return _serde::__private::Err(
417 <__A::Error as _serde::de::Error>::missing_field(
418 "transforms",
419 ),
420 );
421 }
422 };
423 let m_setupStabilization = match m_setupStabilization {
424 _serde::__private::Some(__field) => __field,
425 _serde::__private::None => {
426 return _serde::__private::Err(
427 <__A::Error as _serde::de::Error>::missing_field(
428 "setupStabilization",
429 ),
430 );
431 }
432 };
433 let m_ragdollMotors = match m_ragdollMotors {
434 _serde::__private::Some(__field) => __field,
435 _serde::__private::None => {
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::missing_field(
438 "ragdollMotors",
439 ),
440 );
441 }
442 };
443 let m_angFriction = match m_angFriction {
444 _serde::__private::Some(__field) => __field,
445 _serde::__private::None => {
446 return _serde::__private::Err(
447 <__A::Error as _serde::de::Error>::missing_field(
448 "angFriction",
449 ),
450 );
451 }
452 };
453 let m_twistLimit = match m_twistLimit {
454 _serde::__private::Some(__field) => __field,
455 _serde::__private::None => {
456 return _serde::__private::Err(
457 <__A::Error as _serde::de::Error>::missing_field(
458 "twistLimit",
459 ),
460 );
461 }
462 };
463 let m_coneLimit = match m_coneLimit {
464 _serde::__private::Some(__field) => __field,
465 _serde::__private::None => {
466 return _serde::__private::Err(
467 <__A::Error as _serde::de::Error>::missing_field(
468 "coneLimit",
469 ),
470 );
471 }
472 };
473 let m_planesLimit = match m_planesLimit {
474 _serde::__private::Some(__field) => __field,
475 _serde::__private::None => {
476 return _serde::__private::Err(
477 <__A::Error as _serde::de::Error>::missing_field(
478 "planesLimit",
479 ),
480 );
481 }
482 };
483 let m_ballSocket = match m_ballSocket {
484 _serde::__private::Some(__field) => __field,
485 _serde::__private::None => {
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::missing_field(
488 "ballSocket",
489 ),
490 );
491 }
492 };
493 _serde::__private::Ok(hkpRagdollConstraintDataAtoms {
494 __ptr,
495 m_transforms,
496 m_setupStabilization,
497 m_ragdollMotors,
498 m_angFriction,
499 m_twistLimit,
500 m_coneLimit,
501 m_planesLimit,
502 m_ballSocket,
503 })
504 }
505 #[allow(clippy::manual_unwrap_or_default)]
506 fn visit_struct<__A>(
507 self,
508 mut __map: __A,
509 ) -> _serde::__private::Result<Self::Value, __A::Error>
510 where
511 __A: _serde::de::MapAccess<'de>,
512 {
513 let mut m_transforms: _serde::__private::Option<
514 hkpSetLocalTransformsConstraintAtom,
515 > = _serde::__private::None;
516 let mut m_setupStabilization: _serde::__private::Option<
517 hkpSetupStabilizationAtom,
518 > = _serde::__private::None;
519 let mut m_ragdollMotors: _serde::__private::Option<
520 hkpRagdollMotorConstraintAtom,
521 > = _serde::__private::None;
522 let mut m_angFriction: _serde::__private::Option<
523 hkpAngFrictionConstraintAtom,
524 > = _serde::__private::None;
525 let mut m_twistLimit: _serde::__private::Option<
526 hkpTwistLimitConstraintAtom,
527 > = _serde::__private::None;
528 let mut m_coneLimit: _serde::__private::Option<
529 hkpConeLimitConstraintAtom,
530 > = _serde::__private::None;
531 let mut m_planesLimit: _serde::__private::Option<
532 hkpConeLimitConstraintAtom,
533 > = _serde::__private::None;
534 let mut m_ballSocket: _serde::__private::Option<
535 hkpBallSocketConstraintAtom,
536 > = _serde::__private::None;
537 while let _serde::__private::Some(__key) = {
538 __A::next_key::<__Field>(&mut __map)?
539 } {
540 match __key {
541 __Field::m_transforms => {
542 #[cfg(
543 any(feature = "strict", feature = "ignore_duplicates")
544 )]
545 if _serde::__private::Option::is_some(&m_transforms) {
546 #[cfg(feature = "ignore_duplicates")]
547 {
548 __A::skip_value(&mut __map)?;
549 continue;
550 }
551 #[cfg(feature = "strict")]
552 return _serde::__private::Err(
553 <__A::Error as _serde::de::Error>::duplicate_field(
554 "transforms",
555 ),
556 );
557 }
558 m_transforms = _serde::__private::Some(
559 match __A::next_value::<
560 hkpSetLocalTransformsConstraintAtom,
561 >(&mut __map) {
562 _serde::__private::Ok(__val) => __val,
563 _serde::__private::Err(__err) => {
564 return _serde::__private::Err(__err);
565 }
566 },
567 );
568 }
569 __Field::m_setupStabilization => {
570 #[cfg(
571 any(feature = "strict", feature = "ignore_duplicates")
572 )]
573 if _serde::__private::Option::is_some(
574 &m_setupStabilization,
575 ) {
576 #[cfg(feature = "ignore_duplicates")]
577 {
578 __A::skip_value(&mut __map)?;
579 continue;
580 }
581 #[cfg(feature = "strict")]
582 return _serde::__private::Err(
583 <__A::Error as _serde::de::Error>::duplicate_field(
584 "setupStabilization",
585 ),
586 );
587 }
588 m_setupStabilization = _serde::__private::Some(
589 match __A::next_value::<
590 hkpSetupStabilizationAtom,
591 >(&mut __map) {
592 _serde::__private::Ok(__val) => __val,
593 _serde::__private::Err(__err) => {
594 return _serde::__private::Err(__err);
595 }
596 },
597 );
598 }
599 __Field::m_ragdollMotors => {
600 #[cfg(
601 any(feature = "strict", feature = "ignore_duplicates")
602 )]
603 if _serde::__private::Option::is_some(&m_ragdollMotors) {
604 #[cfg(feature = "ignore_duplicates")]
605 {
606 __A::skip_value(&mut __map)?;
607 continue;
608 }
609 #[cfg(feature = "strict")]
610 return _serde::__private::Err(
611 <__A::Error as _serde::de::Error>::duplicate_field(
612 "ragdollMotors",
613 ),
614 );
615 }
616 m_ragdollMotors = _serde::__private::Some(
617 match __A::next_value::<
618 hkpRagdollMotorConstraintAtom,
619 >(&mut __map) {
620 _serde::__private::Ok(__val) => __val,
621 _serde::__private::Err(__err) => {
622 return _serde::__private::Err(__err);
623 }
624 },
625 );
626 }
627 __Field::m_angFriction => {
628 #[cfg(
629 any(feature = "strict", feature = "ignore_duplicates")
630 )]
631 if _serde::__private::Option::is_some(&m_angFriction) {
632 #[cfg(feature = "ignore_duplicates")]
633 {
634 __A::skip_value(&mut __map)?;
635 continue;
636 }
637 #[cfg(feature = "strict")]
638 return _serde::__private::Err(
639 <__A::Error as _serde::de::Error>::duplicate_field(
640 "angFriction",
641 ),
642 );
643 }
644 m_angFriction = _serde::__private::Some(
645 match __A::next_value::<
646 hkpAngFrictionConstraintAtom,
647 >(&mut __map) {
648 _serde::__private::Ok(__val) => __val,
649 _serde::__private::Err(__err) => {
650 return _serde::__private::Err(__err);
651 }
652 },
653 );
654 }
655 __Field::m_twistLimit => {
656 #[cfg(
657 any(feature = "strict", feature = "ignore_duplicates")
658 )]
659 if _serde::__private::Option::is_some(&m_twistLimit) {
660 #[cfg(feature = "ignore_duplicates")]
661 {
662 __A::skip_value(&mut __map)?;
663 continue;
664 }
665 #[cfg(feature = "strict")]
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::duplicate_field(
668 "twistLimit",
669 ),
670 );
671 }
672 m_twistLimit = _serde::__private::Some(
673 match __A::next_value::<
674 hkpTwistLimitConstraintAtom,
675 >(&mut __map) {
676 _serde::__private::Ok(__val) => __val,
677 _serde::__private::Err(__err) => {
678 return _serde::__private::Err(__err);
679 }
680 },
681 );
682 }
683 __Field::m_coneLimit => {
684 #[cfg(
685 any(feature = "strict", feature = "ignore_duplicates")
686 )]
687 if _serde::__private::Option::is_some(&m_coneLimit) {
688 #[cfg(feature = "ignore_duplicates")]
689 {
690 __A::skip_value(&mut __map)?;
691 continue;
692 }
693 #[cfg(feature = "strict")]
694 return _serde::__private::Err(
695 <__A::Error as _serde::de::Error>::duplicate_field(
696 "coneLimit",
697 ),
698 );
699 }
700 m_coneLimit = _serde::__private::Some(
701 match __A::next_value::<
702 hkpConeLimitConstraintAtom,
703 >(&mut __map) {
704 _serde::__private::Ok(__val) => __val,
705 _serde::__private::Err(__err) => {
706 return _serde::__private::Err(__err);
707 }
708 },
709 );
710 }
711 __Field::m_planesLimit => {
712 #[cfg(
713 any(feature = "strict", feature = "ignore_duplicates")
714 )]
715 if _serde::__private::Option::is_some(&m_planesLimit) {
716 #[cfg(feature = "ignore_duplicates")]
717 {
718 __A::skip_value(&mut __map)?;
719 continue;
720 }
721 #[cfg(feature = "strict")]
722 return _serde::__private::Err(
723 <__A::Error as _serde::de::Error>::duplicate_field(
724 "planesLimit",
725 ),
726 );
727 }
728 m_planesLimit = _serde::__private::Some(
729 match __A::next_value::<
730 hkpConeLimitConstraintAtom,
731 >(&mut __map) {
732 _serde::__private::Ok(__val) => __val,
733 _serde::__private::Err(__err) => {
734 return _serde::__private::Err(__err);
735 }
736 },
737 );
738 }
739 __Field::m_ballSocket => {
740 #[cfg(
741 any(feature = "strict", feature = "ignore_duplicates")
742 )]
743 if _serde::__private::Option::is_some(&m_ballSocket) {
744 #[cfg(feature = "ignore_duplicates")]
745 {
746 __A::skip_value(&mut __map)?;
747 continue;
748 }
749 #[cfg(feature = "strict")]
750 return _serde::__private::Err(
751 <__A::Error as _serde::de::Error>::duplicate_field(
752 "ballSocket",
753 ),
754 );
755 }
756 m_ballSocket = _serde::__private::Some(
757 match __A::next_value::<
758 hkpBallSocketConstraintAtom,
759 >(&mut __map) {
760 _serde::__private::Ok(__val) => __val,
761 _serde::__private::Err(__err) => {
762 return _serde::__private::Err(__err);
763 }
764 },
765 );
766 }
767 _ => __A::skip_value(&mut __map)?,
768 }
769 }
770 let m_transforms = match m_transforms {
771 _serde::__private::Some(__field) => __field,
772 _serde::__private::None => {
773 #[cfg(feature = "strict")]
774 return _serde::__private::Err(
775 <__A::Error as _serde::de::Error>::missing_field(
776 "transforms",
777 ),
778 );
779 #[cfg(not(feature = "strict"))] Default::default()
780 }
781 };
782 let m_setupStabilization = match m_setupStabilization {
783 _serde::__private::Some(__field) => __field,
784 _serde::__private::None => {
785 #[cfg(feature = "strict")]
786 return _serde::__private::Err(
787 <__A::Error as _serde::de::Error>::missing_field(
788 "setupStabilization",
789 ),
790 );
791 #[cfg(not(feature = "strict"))] Default::default()
792 }
793 };
794 let m_ragdollMotors = match m_ragdollMotors {
795 _serde::__private::Some(__field) => __field,
796 _serde::__private::None => {
797 #[cfg(feature = "strict")]
798 return _serde::__private::Err(
799 <__A::Error as _serde::de::Error>::missing_field(
800 "ragdollMotors",
801 ),
802 );
803 #[cfg(not(feature = "strict"))] Default::default()
804 }
805 };
806 let m_angFriction = match m_angFriction {
807 _serde::__private::Some(__field) => __field,
808 _serde::__private::None => {
809 #[cfg(feature = "strict")]
810 return _serde::__private::Err(
811 <__A::Error as _serde::de::Error>::missing_field(
812 "angFriction",
813 ),
814 );
815 #[cfg(not(feature = "strict"))] Default::default()
816 }
817 };
818 let m_twistLimit = match m_twistLimit {
819 _serde::__private::Some(__field) => __field,
820 _serde::__private::None => {
821 #[cfg(feature = "strict")]
822 return _serde::__private::Err(
823 <__A::Error as _serde::de::Error>::missing_field(
824 "twistLimit",
825 ),
826 );
827 #[cfg(not(feature = "strict"))] Default::default()
828 }
829 };
830 let m_coneLimit = match m_coneLimit {
831 _serde::__private::Some(__field) => __field,
832 _serde::__private::None => {
833 #[cfg(feature = "strict")]
834 return _serde::__private::Err(
835 <__A::Error as _serde::de::Error>::missing_field(
836 "coneLimit",
837 ),
838 );
839 #[cfg(not(feature = "strict"))] Default::default()
840 }
841 };
842 let m_planesLimit = match m_planesLimit {
843 _serde::__private::Some(__field) => __field,
844 _serde::__private::None => {
845 #[cfg(feature = "strict")]
846 return _serde::__private::Err(
847 <__A::Error as _serde::de::Error>::missing_field(
848 "planesLimit",
849 ),
850 );
851 #[cfg(not(feature = "strict"))] Default::default()
852 }
853 };
854 let m_ballSocket = match m_ballSocket {
855 _serde::__private::Some(__field) => __field,
856 _serde::__private::None => {
857 #[cfg(feature = "strict")]
858 return _serde::__private::Err(
859 <__A::Error as _serde::de::Error>::missing_field(
860 "ballSocket",
861 ),
862 );
863 #[cfg(not(feature = "strict"))] Default::default()
864 }
865 };
866 let __ptr = __A::class_ptr(&mut __map);
867 _serde::__private::Ok(hkpRagdollConstraintDataAtoms {
868 __ptr,
869 m_transforms,
870 m_setupStabilization,
871 m_ragdollMotors,
872 m_angFriction,
873 m_twistLimit,
874 m_coneLimit,
875 m_planesLimit,
876 m_ballSocket,
877 })
878 }
879 }
880 const FIELDS: &[&str] = &[
881 "transforms",
882 "setupStabilization",
883 "ragdollMotors",
884 "angFriction",
885 "twistLimit",
886 "coneLimit",
887 "planesLimit",
888 "ballSocket",
889 ];
890 _serde::Deserializer::deserialize_struct(
891 deserializer,
892 "hkpRagdollConstraintDataAtoms",
893 FIELDS,
894 __hkpRagdollConstraintDataAtomsVisitor {
895 marker: _serde::__private::PhantomData::<
896 hkpRagdollConstraintDataAtoms,
897 >,
898 lifetime: _serde::__private::PhantomData,
899 },
900 )
901 }
902 }
903};