havok_classes/generated/
hkpLimitedHingeConstraintDataAtoms_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpLimitedHingeConstraintDataAtoms`
5/// - version: `1`
6/// - signature: `0x54c7715b`
7/// - size: `240`(x86)/`240`(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 hkpLimitedHingeConstraintDataAtoms {
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    /// # C++ Info
27    /// - name: `transforms`(ctype: `struct hkpSetLocalTransformsConstraintAtom`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `144`(x86)/`144`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "transforms"))]
31    #[cfg_attr(feature = "serde", serde(rename = "transforms"))]
32    pub m_transforms: hkpSetLocalTransformsConstraintAtom,
33    /// # C++ Info
34    /// - name: `setupStabilization`(ctype: `struct hkpSetupStabilizationAtom`)
35    /// - offset: `144`(x86)/`144`(x86_64)
36    /// - type_size: ` 16`(x86)/` 16`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "setupStabilization"))]
38    #[cfg_attr(feature = "serde", serde(rename = "setupStabilization"))]
39    pub m_setupStabilization: hkpSetupStabilizationAtom,
40    /// # C++ Info
41    /// - name: `angMotor`(ctype: `struct hkpAngMotorConstraintAtom`)
42    /// - offset: `160`(x86)/`160`(x86_64)
43    /// - type_size: ` 20`(x86)/` 24`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "angMotor"))]
45    #[cfg_attr(feature = "serde", serde(rename = "angMotor"))]
46    pub m_angMotor: hkpAngMotorConstraintAtom,
47    /// # C++ Info
48    /// - name: `angFriction`(ctype: `struct hkpAngFrictionConstraintAtom`)
49    /// - offset: `180`(x86)/`184`(x86_64)
50    /// - type_size: ` 12`(x86)/` 12`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "angFriction"))]
52    #[cfg_attr(feature = "serde", serde(rename = "angFriction"))]
53    pub m_angFriction: hkpAngFrictionConstraintAtom,
54    /// # C++ Info
55    /// - name: `angLimit`(ctype: `struct hkpAngLimitConstraintAtom`)
56    /// - offset: `192`(x86)/`196`(x86_64)
57    /// - type_size: ` 16`(x86)/` 16`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "angLimit"))]
59    #[cfg_attr(feature = "serde", serde(rename = "angLimit"))]
60    pub m_angLimit: hkpAngLimitConstraintAtom,
61    /// # C++ Info
62    /// - name: `2dAng`(ctype: `struct hkp2dAngConstraintAtom`)
63    /// - offset: `208`(x86)/`212`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "2dAng"))]
66    #[cfg_attr(feature = "serde", serde(rename = "2dAng"))]
67    pub m_2dAng: hkp2dAngConstraintAtom,
68    /// # C++ Info
69    /// - name: `ballSocket`(ctype: `struct hkpBallSocketConstraintAtom`)
70    /// - offset: `212`(x86)/`216`(x86_64)
71    /// - type_size: ` 16`(x86)/` 16`(x86_64)
72    #[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                /// Intended for use in XML.
158                #[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};