havok_classes/generated/
hkpSimpleContactConstraintAtom_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpSimpleContactConstraintAtom`
5/// - version: `0`
6/// - signature: `0x920df11a`
7/// - size: ` 48`(x86)/` 48`(x86_64)
8/// -  vtable: `false`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkpSimpleContactConstraintAtom {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkpConstraintAtom,
30    /// # C++ Info
31    /// - name: `sizeOfAllAtoms`(ctype: `hkUint16`)
32    /// - offset: `  2`(x86)/`  2`(x86_64)
33    /// - type_size: `  2`(x86)/`  2`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "sizeOfAllAtoms"))]
35    #[cfg_attr(feature = "serde", serde(rename = "sizeOfAllAtoms"))]
36    pub m_sizeOfAllAtoms: u16,
37    /// # C++ Info
38    /// - name: `numContactPoints`(ctype: `hkUint16`)
39    /// - offset: `  4`(x86)/`  4`(x86_64)
40    /// - type_size: `  2`(x86)/`  2`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "numContactPoints"))]
42    #[cfg_attr(feature = "serde", serde(rename = "numContactPoints"))]
43    pub m_numContactPoints: u16,
44    /// # C++ Info
45    /// - name: `numReservedContactPoints`(ctype: `hkUint16`)
46    /// - offset: `  6`(x86)/`  6`(x86_64)
47    /// - type_size: `  2`(x86)/`  2`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "numReservedContactPoints"))]
49    #[cfg_attr(feature = "serde", serde(rename = "numReservedContactPoints"))]
50    pub m_numReservedContactPoints: u16,
51    /// # C++ Info
52    /// - name: `numUserDatasForBodyA`(ctype: `hkUint8`)
53    /// - offset: `  8`(x86)/`  8`(x86_64)
54    /// - type_size: `  1`(x86)/`  1`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "numUserDatasForBodyA"))]
56    #[cfg_attr(feature = "serde", serde(rename = "numUserDatasForBodyA"))]
57    pub m_numUserDatasForBodyA: u8,
58    /// # C++ Info
59    /// - name: `numUserDatasForBodyB`(ctype: `hkUint8`)
60    /// - offset: `  9`(x86)/`  9`(x86_64)
61    /// - type_size: `  1`(x86)/`  1`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "numUserDatasForBodyB"))]
63    #[cfg_attr(feature = "serde", serde(rename = "numUserDatasForBodyB"))]
64    pub m_numUserDatasForBodyB: u8,
65    /// # C++ Info
66    /// - name: `contactPointPropertiesStriding`(ctype: `hkUint8`)
67    /// - offset: ` 10`(x86)/` 10`(x86_64)
68    /// - type_size: `  1`(x86)/`  1`(x86_64)
69    #[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    /// # C++ Info
76    /// - name: `maxNumContactPoints`(ctype: `hkUint16`)
77    /// - offset: ` 12`(x86)/` 12`(x86_64)
78    /// - type_size: `  2`(x86)/`  2`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "maxNumContactPoints"))]
80    #[cfg_attr(feature = "serde", serde(rename = "maxNumContactPoints"))]
81    pub m_maxNumContactPoints: u16,
82    /// # C++ Info
83    /// - name: `info`(ctype: `struct hkpSimpleContactConstraintDataInfo`)
84    /// - offset: ` 16`(x86)/` 16`(x86_64)
85    /// - type_size: ` 32`(x86)/` 32`(x86_64)
86    /// - flags: `ALIGN_16`
87    #[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                /// Intended for use in XML.
182                #[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};