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