havok_classes/generated/
hkpAngMotorConstraintAtom_.rs

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