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