havok_classes/generated/
hkbFootIkModifierLeg_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbFootIkModifierLeg`
5/// - version: `2`
6/// - signature: `0x9f3e3a04`
7/// - size: `160`(x86)/`160`(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 hkbFootIkModifierLeg {
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: `originalAnkleTransformMS`(ctype: `hkQsTransform`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 48`(x86)/` 48`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "originalAnkleTransformMS"))]
31    #[cfg_attr(feature = "serde", serde(rename = "originalAnkleTransformMS"))]
32    pub m_originalAnkleTransformMS: QsTransform,
33    /// # C++ Info
34    /// - name: `prevAnkleRotLS`(ctype: `hkQuaternion`)
35    /// - offset: ` 48`(x86)/` 48`(x86_64)
36    /// - type_size: ` 16`(x86)/` 16`(x86_64)
37    /// - flags: `SERIALIZE_IGNORED`
38    #[cfg_attr(feature = "json_schema", schemars(rename = "prevAnkleRotLS"))]
39    #[cfg_attr(feature = "serde", serde(rename = "prevAnkleRotLS"))]
40    pub m_prevAnkleRotLS: Quaternion,
41    /// # C++ Info
42    /// - name: `kneeAxisLS`(ctype: `hkVector4`)
43    /// - offset: ` 64`(x86)/` 64`(x86_64)
44    /// - type_size: ` 16`(x86)/` 16`(x86_64)
45    #[cfg_attr(feature = "json_schema", schemars(rename = "kneeAxisLS"))]
46    #[cfg_attr(feature = "serde", serde(rename = "kneeAxisLS"))]
47    pub m_kneeAxisLS: Vector4,
48    /// # C++ Info
49    /// - name: `footEndLS`(ctype: `hkVector4`)
50    /// - offset: ` 80`(x86)/` 80`(x86_64)
51    /// - type_size: ` 16`(x86)/` 16`(x86_64)
52    #[cfg_attr(feature = "json_schema", schemars(rename = "footEndLS"))]
53    #[cfg_attr(feature = "serde", serde(rename = "footEndLS"))]
54    pub m_footEndLS: Vector4,
55    /// # C++ Info
56    /// - name: `ungroundedEvent`(ctype: `struct hkbEventProperty`)
57    /// - offset: ` 96`(x86)/` 96`(x86_64)
58    /// - type_size: `  8`(x86)/` 16`(x86_64)
59    #[cfg_attr(feature = "json_schema", schemars(rename = "ungroundedEvent"))]
60    #[cfg_attr(feature = "serde", serde(rename = "ungroundedEvent"))]
61    pub m_ungroundedEvent: hkbEventProperty,
62    /// # C++ Info
63    /// - name: `footPlantedAnkleHeightMS`(ctype: `hkReal`)
64    /// - offset: `104`(x86)/`112`(x86_64)
65    /// - type_size: `  4`(x86)/`  4`(x86_64)
66    #[cfg_attr(feature = "json_schema", schemars(rename = "footPlantedAnkleHeightMS"))]
67    #[cfg_attr(feature = "serde", serde(rename = "footPlantedAnkleHeightMS"))]
68    pub m_footPlantedAnkleHeightMS: f32,
69    /// # C++ Info
70    /// - name: `footRaisedAnkleHeightMS`(ctype: `hkReal`)
71    /// - offset: `108`(x86)/`116`(x86_64)
72    /// - type_size: `  4`(x86)/`  4`(x86_64)
73    #[cfg_attr(feature = "json_schema", schemars(rename = "footRaisedAnkleHeightMS"))]
74    #[cfg_attr(feature = "serde", serde(rename = "footRaisedAnkleHeightMS"))]
75    pub m_footRaisedAnkleHeightMS: f32,
76    /// # C++ Info
77    /// - name: `maxAnkleHeightMS`(ctype: `hkReal`)
78    /// - offset: `112`(x86)/`120`(x86_64)
79    /// - type_size: `  4`(x86)/`  4`(x86_64)
80    #[cfg_attr(feature = "json_schema", schemars(rename = "maxAnkleHeightMS"))]
81    #[cfg_attr(feature = "serde", serde(rename = "maxAnkleHeightMS"))]
82    pub m_maxAnkleHeightMS: f32,
83    /// # C++ Info
84    /// - name: `minAnkleHeightMS`(ctype: `hkReal`)
85    /// - offset: `116`(x86)/`124`(x86_64)
86    /// - type_size: `  4`(x86)/`  4`(x86_64)
87    #[cfg_attr(feature = "json_schema", schemars(rename = "minAnkleHeightMS"))]
88    #[cfg_attr(feature = "serde", serde(rename = "minAnkleHeightMS"))]
89    pub m_minAnkleHeightMS: f32,
90    /// # C++ Info
91    /// - name: `maxKneeAngleDegrees`(ctype: `hkReal`)
92    /// - offset: `120`(x86)/`128`(x86_64)
93    /// - type_size: `  4`(x86)/`  4`(x86_64)
94    #[cfg_attr(feature = "json_schema", schemars(rename = "maxKneeAngleDegrees"))]
95    #[cfg_attr(feature = "serde", serde(rename = "maxKneeAngleDegrees"))]
96    pub m_maxKneeAngleDegrees: f32,
97    /// # C++ Info
98    /// - name: `minKneeAngleDegrees`(ctype: `hkReal`)
99    /// - offset: `124`(x86)/`132`(x86_64)
100    /// - type_size: `  4`(x86)/`  4`(x86_64)
101    #[cfg_attr(feature = "json_schema", schemars(rename = "minKneeAngleDegrees"))]
102    #[cfg_attr(feature = "serde", serde(rename = "minKneeAngleDegrees"))]
103    pub m_minKneeAngleDegrees: f32,
104    /// # C++ Info
105    /// - name: `verticalError`(ctype: `hkReal`)
106    /// - offset: `128`(x86)/`136`(x86_64)
107    /// - type_size: `  4`(x86)/`  4`(x86_64)
108    #[cfg_attr(feature = "json_schema", schemars(rename = "verticalError"))]
109    #[cfg_attr(feature = "serde", serde(rename = "verticalError"))]
110    pub m_verticalError: f32,
111    /// # C++ Info
112    /// - name: `maxAnkleAngleDegrees`(ctype: `hkReal`)
113    /// - offset: `132`(x86)/`140`(x86_64)
114    /// - type_size: `  4`(x86)/`  4`(x86_64)
115    #[cfg_attr(feature = "json_schema", schemars(rename = "maxAnkleAngleDegrees"))]
116    #[cfg_attr(feature = "serde", serde(rename = "maxAnkleAngleDegrees"))]
117    pub m_maxAnkleAngleDegrees: f32,
118    /// # C++ Info
119    /// - name: `hipIndex`(ctype: `hkInt16`)
120    /// - offset: `136`(x86)/`144`(x86_64)
121    /// - type_size: `  2`(x86)/`  2`(x86_64)
122    #[cfg_attr(feature = "json_schema", schemars(rename = "hipIndex"))]
123    #[cfg_attr(feature = "serde", serde(rename = "hipIndex"))]
124    pub m_hipIndex: i16,
125    /// # C++ Info
126    /// - name: `kneeIndex`(ctype: `hkInt16`)
127    /// - offset: `138`(x86)/`146`(x86_64)
128    /// - type_size: `  2`(x86)/`  2`(x86_64)
129    #[cfg_attr(feature = "json_schema", schemars(rename = "kneeIndex"))]
130    #[cfg_attr(feature = "serde", serde(rename = "kneeIndex"))]
131    pub m_kneeIndex: i16,
132    /// # C++ Info
133    /// - name: `ankleIndex`(ctype: `hkInt16`)
134    /// - offset: `140`(x86)/`148`(x86_64)
135    /// - type_size: `  2`(x86)/`  2`(x86_64)
136    #[cfg_attr(feature = "json_schema", schemars(rename = "ankleIndex"))]
137    #[cfg_attr(feature = "serde", serde(rename = "ankleIndex"))]
138    pub m_ankleIndex: i16,
139    /// # C++ Info
140    /// - name: `hitSomething`(ctype: `hkBool`)
141    /// - offset: `142`(x86)/`150`(x86_64)
142    /// - type_size: `  1`(x86)/`  1`(x86_64)
143    #[cfg_attr(feature = "json_schema", schemars(rename = "hitSomething"))]
144    #[cfg_attr(feature = "serde", serde(rename = "hitSomething"))]
145    pub m_hitSomething: bool,
146    /// # C++ Info
147    /// - name: `isPlantedMS`(ctype: `hkBool`)
148    /// - offset: `143`(x86)/`151`(x86_64)
149    /// - type_size: `  1`(x86)/`  1`(x86_64)
150    #[cfg_attr(feature = "json_schema", schemars(rename = "isPlantedMS"))]
151    #[cfg_attr(feature = "serde", serde(rename = "isPlantedMS"))]
152    pub m_isPlantedMS: bool,
153    /// # C++ Info
154    /// - name: `isOriginalAnkleTransformMSSet`(ctype: `hkBool`)
155    /// - offset: `144`(x86)/`152`(x86_64)
156    /// - type_size: `  1`(x86)/`  1`(x86_64)
157    #[cfg_attr(
158        feature = "json_schema",
159        schemars(rename = "isOriginalAnkleTransformMSSet")
160    )]
161    #[cfg_attr(feature = "serde", serde(rename = "isOriginalAnkleTransformMSSet"))]
162    pub m_isOriginalAnkleTransformMSSet: bool,
163}
164const _: () = {
165    use havok_serde as _serde;
166    impl _serde::HavokClass for hkbFootIkModifierLeg {
167        #[inline]
168        fn name(&self) -> &'static str {
169            "hkbFootIkModifierLeg"
170        }
171        #[inline]
172        fn signature(&self) -> _serde::__private::Signature {
173            _serde::__private::Signature::new(0x9f3e3a04)
174        }
175        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
176        fn deps_indexes(&self) -> Vec<usize> {
177            let mut v = Vec::new();
178            v.extend(self.m_ungroundedEvent.deps_indexes());
179            v
180        }
181    }
182    impl _serde::Serialize for hkbFootIkModifierLeg {
183        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
184        where
185            S: _serde::ser::Serializer,
186        {
187            let class_meta = self
188                .__ptr
189                .map(|name| (name, _serde::__private::Signature::new(0x9f3e3a04)));
190            let mut serializer = __serializer
191                .serialize_struct("hkbFootIkModifierLeg", class_meta, (160u64, 160u64))?;
192            serializer
193                .serialize_field(
194                    "originalAnkleTransformMS",
195                    &self.m_originalAnkleTransformMS,
196                )?;
197            serializer.skip_field("prevAnkleRotLS", &self.m_prevAnkleRotLS)?;
198            serializer.serialize_field("kneeAxisLS", &self.m_kneeAxisLS)?;
199            serializer.serialize_field("footEndLS", &self.m_footEndLS)?;
200            serializer.serialize_field("ungroundedEvent", &self.m_ungroundedEvent)?;
201            serializer
202                .serialize_field(
203                    "footPlantedAnkleHeightMS",
204                    &self.m_footPlantedAnkleHeightMS,
205                )?;
206            serializer
207                .serialize_field(
208                    "footRaisedAnkleHeightMS",
209                    &self.m_footRaisedAnkleHeightMS,
210                )?;
211            serializer.serialize_field("maxAnkleHeightMS", &self.m_maxAnkleHeightMS)?;
212            serializer.serialize_field("minAnkleHeightMS", &self.m_minAnkleHeightMS)?;
213            serializer
214                .serialize_field("maxKneeAngleDegrees", &self.m_maxKneeAngleDegrees)?;
215            serializer
216                .serialize_field("minKneeAngleDegrees", &self.m_minKneeAngleDegrees)?;
217            serializer.serialize_field("verticalError", &self.m_verticalError)?;
218            serializer
219                .serialize_field("maxAnkleAngleDegrees", &self.m_maxAnkleAngleDegrees)?;
220            serializer.serialize_field("hipIndex", &self.m_hipIndex)?;
221            serializer.serialize_field("kneeIndex", &self.m_kneeIndex)?;
222            serializer.serialize_field("ankleIndex", &self.m_ankleIndex)?;
223            serializer.serialize_field("hitSomething", &self.m_hitSomething)?;
224            serializer.serialize_field("isPlantedMS", &self.m_isPlantedMS)?;
225            serializer
226                .serialize_field(
227                    "isOriginalAnkleTransformMSSet",
228                    &self.m_isOriginalAnkleTransformMSSet,
229                )?;
230            serializer.pad_field([0u8; 15usize].as_slice(), [0u8; 7usize].as_slice())?;
231            serializer.end()
232        }
233    }
234};
235#[doc(hidden)]
236#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
237const _: () = {
238    use havok_serde as _serde;
239    #[automatically_derived]
240    impl<'de> _serde::Deserialize<'de> for hkbFootIkModifierLeg {
241        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
242        where
243            __D: _serde::Deserializer<'de>,
244        {
245            #[allow(non_camel_case_types)]
246            enum __Field {
247                m_originalAnkleTransformMS,
248                m_kneeAxisLS,
249                m_footEndLS,
250                m_ungroundedEvent,
251                m_footPlantedAnkleHeightMS,
252                m_footRaisedAnkleHeightMS,
253                m_maxAnkleHeightMS,
254                m_minAnkleHeightMS,
255                m_maxKneeAngleDegrees,
256                m_minKneeAngleDegrees,
257                m_verticalError,
258                m_maxAnkleAngleDegrees,
259                m_hipIndex,
260                m_kneeIndex,
261                m_ankleIndex,
262                m_hitSomething,
263                m_isPlantedMS,
264                m_isOriginalAnkleTransformMSSet,
265                __ignore,
266            }
267            struct __FieldVisitor;
268            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
269                type Value = __Field;
270                fn expecting(
271                    &self,
272                    __formatter: &mut core::fmt::Formatter,
273                ) -> core::fmt::Result {
274                    core::fmt::Formatter::write_str(__formatter, "field identifier")
275                }
276                /// Intended for use in XML.
277                #[allow(clippy::match_single_binding)]
278                #[allow(clippy::reversed_empty_ranges)]
279                #[allow(clippy::single_match)]
280                fn visit_key<__E>(
281                    self,
282                    __value: &str,
283                ) -> core::result::Result<Self::Value, __E>
284                where
285                    __E: _serde::de::Error,
286                {
287                    match __value {
288                        "originalAnkleTransformMS" => {
289                            Ok(__Field::m_originalAnkleTransformMS)
290                        }
291                        "kneeAxisLS" => Ok(__Field::m_kneeAxisLS),
292                        "footEndLS" => Ok(__Field::m_footEndLS),
293                        "ungroundedEvent" => Ok(__Field::m_ungroundedEvent),
294                        "footPlantedAnkleHeightMS" => {
295                            Ok(__Field::m_footPlantedAnkleHeightMS)
296                        }
297                        "footRaisedAnkleHeightMS" => {
298                            Ok(__Field::m_footRaisedAnkleHeightMS)
299                        }
300                        "maxAnkleHeightMS" => Ok(__Field::m_maxAnkleHeightMS),
301                        "minAnkleHeightMS" => Ok(__Field::m_minAnkleHeightMS),
302                        "maxKneeAngleDegrees" => Ok(__Field::m_maxKneeAngleDegrees),
303                        "minKneeAngleDegrees" => Ok(__Field::m_minKneeAngleDegrees),
304                        "verticalError" => Ok(__Field::m_verticalError),
305                        "maxAnkleAngleDegrees" => Ok(__Field::m_maxAnkleAngleDegrees),
306                        "hipIndex" => Ok(__Field::m_hipIndex),
307                        "kneeIndex" => Ok(__Field::m_kneeIndex),
308                        "ankleIndex" => Ok(__Field::m_ankleIndex),
309                        "hitSomething" => Ok(__Field::m_hitSomething),
310                        "isPlantedMS" => Ok(__Field::m_isPlantedMS),
311                        "isOriginalAnkleTransformMSSet" => {
312                            Ok(__Field::m_isOriginalAnkleTransformMSSet)
313                        }
314                        _ => Ok(__Field::__ignore),
315                    }
316                }
317            }
318            impl<'de> _serde::Deserialize<'de> for __Field {
319                #[inline]
320                fn deserialize<__D>(
321                    __deserializer: __D,
322                ) -> core::result::Result<Self, __D::Error>
323                where
324                    __D: _serde::Deserializer<'de>,
325                {
326                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
327                }
328            }
329            struct __hkbFootIkModifierLegVisitor<'de> {
330                marker: _serde::__private::PhantomData<hkbFootIkModifierLeg>,
331                lifetime: _serde::__private::PhantomData<&'de ()>,
332            }
333            #[allow(clippy::match_single_binding)]
334            #[allow(clippy::reversed_empty_ranges)]
335            #[allow(clippy::single_match)]
336            impl<'de> _serde::de::Visitor<'de> for __hkbFootIkModifierLegVisitor<'de> {
337                type Value = hkbFootIkModifierLeg;
338                fn expecting(
339                    &self,
340                    __formatter: &mut core::fmt::Formatter,
341                ) -> core::fmt::Result {
342                    core::fmt::Formatter::write_str(
343                        __formatter,
344                        "struct hkbFootIkModifierLeg",
345                    )
346                }
347                fn visit_struct_for_bytes<__A>(
348                    self,
349                    mut __map: __A,
350                ) -> _serde::__private::Result<Self::Value, __A::Error>
351                where
352                    __A: _serde::de::MapAccess<'de>,
353                {
354                    let __ptr = __A::class_ptr(&mut __map);
355                    let mut m_originalAnkleTransformMS: _serde::__private::Option<
356                        QsTransform,
357                    > = _serde::__private::None;
358                    let mut m_prevAnkleRotLS: _serde::__private::Option<Quaternion> = _serde::__private::None;
359                    let mut m_kneeAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
360                    let mut m_footEndLS: _serde::__private::Option<Vector4> = _serde::__private::None;
361                    let mut m_ungroundedEvent: _serde::__private::Option<
362                        hkbEventProperty,
363                    > = _serde::__private::None;
364                    let mut m_footPlantedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
365                    let mut m_footRaisedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
366                    let mut m_maxAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
367                    let mut m_minAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
368                    let mut m_maxKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
369                    let mut m_minKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
370                    let mut m_verticalError: _serde::__private::Option<f32> = _serde::__private::None;
371                    let mut m_maxAnkleAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
372                    let mut m_hipIndex: _serde::__private::Option<i16> = _serde::__private::None;
373                    let mut m_kneeIndex: _serde::__private::Option<i16> = _serde::__private::None;
374                    let mut m_ankleIndex: _serde::__private::Option<i16> = _serde::__private::None;
375                    let mut m_hitSomething: _serde::__private::Option<bool> = _serde::__private::None;
376                    let mut m_isPlantedMS: _serde::__private::Option<bool> = _serde::__private::None;
377                    let mut m_isOriginalAnkleTransformMSSet: _serde::__private::Option<
378                        bool,
379                    > = _serde::__private::None;
380                    for i in 0..19usize {
381                        match i {
382                            0usize => {
383                                if _serde::__private::Option::is_some(
384                                    &m_originalAnkleTransformMS,
385                                ) {
386                                    return _serde::__private::Err(
387                                        <__A::Error as _serde::de::Error>::duplicate_field(
388                                            "originalAnkleTransformMS",
389                                        ),
390                                    );
391                                }
392                                m_originalAnkleTransformMS = _serde::__private::Some(
393                                    match __A::next_value::<QsTransform>(&mut __map) {
394                                        _serde::__private::Ok(__val) => __val,
395                                        _serde::__private::Err(__err) => {
396                                            return _serde::__private::Err(__err);
397                                        }
398                                    },
399                                );
400                            }
401                            1usize => {
402                                if _serde::__private::Option::is_some(&m_prevAnkleRotLS) {
403                                    return _serde::__private::Err(
404                                        <__A::Error as _serde::de::Error>::duplicate_field(
405                                            "prevAnkleRotLS",
406                                        ),
407                                    );
408                                }
409                                m_prevAnkleRotLS = _serde::__private::Some(
410                                    match __A::next_value::<Quaternion>(&mut __map) {
411                                        _serde::__private::Ok(__val) => __val,
412                                        _serde::__private::Err(__err) => {
413                                            return _serde::__private::Err(__err);
414                                        }
415                                    },
416                                );
417                            }
418                            2usize => {
419                                if _serde::__private::Option::is_some(&m_kneeAxisLS) {
420                                    return _serde::__private::Err(
421                                        <__A::Error as _serde::de::Error>::duplicate_field(
422                                            "kneeAxisLS",
423                                        ),
424                                    );
425                                }
426                                m_kneeAxisLS = _serde::__private::Some(
427                                    match __A::next_value::<Vector4>(&mut __map) {
428                                        _serde::__private::Ok(__val) => __val,
429                                        _serde::__private::Err(__err) => {
430                                            return _serde::__private::Err(__err);
431                                        }
432                                    },
433                                );
434                            }
435                            3usize => {
436                                if _serde::__private::Option::is_some(&m_footEndLS) {
437                                    return _serde::__private::Err(
438                                        <__A::Error as _serde::de::Error>::duplicate_field(
439                                            "footEndLS",
440                                        ),
441                                    );
442                                }
443                                m_footEndLS = _serde::__private::Some(
444                                    match __A::next_value::<Vector4>(&mut __map) {
445                                        _serde::__private::Ok(__val) => __val,
446                                        _serde::__private::Err(__err) => {
447                                            return _serde::__private::Err(__err);
448                                        }
449                                    },
450                                );
451                            }
452                            4usize => {
453                                if _serde::__private::Option::is_some(&m_ungroundedEvent) {
454                                    return _serde::__private::Err(
455                                        <__A::Error as _serde::de::Error>::duplicate_field(
456                                            "ungroundedEvent",
457                                        ),
458                                    );
459                                }
460                                m_ungroundedEvent = _serde::__private::Some(
461                                    match __A::next_value::<hkbEventProperty>(&mut __map) {
462                                        _serde::__private::Ok(__val) => __val,
463                                        _serde::__private::Err(__err) => {
464                                            return _serde::__private::Err(__err);
465                                        }
466                                    },
467                                );
468                            }
469                            5usize => {
470                                if _serde::__private::Option::is_some(
471                                    &m_footPlantedAnkleHeightMS,
472                                ) {
473                                    return _serde::__private::Err(
474                                        <__A::Error as _serde::de::Error>::duplicate_field(
475                                            "footPlantedAnkleHeightMS",
476                                        ),
477                                    );
478                                }
479                                m_footPlantedAnkleHeightMS = _serde::__private::Some(
480                                    match __A::next_value::<f32>(&mut __map) {
481                                        _serde::__private::Ok(__val) => __val,
482                                        _serde::__private::Err(__err) => {
483                                            return _serde::__private::Err(__err);
484                                        }
485                                    },
486                                );
487                            }
488                            6usize => {
489                                if _serde::__private::Option::is_some(
490                                    &m_footRaisedAnkleHeightMS,
491                                ) {
492                                    return _serde::__private::Err(
493                                        <__A::Error as _serde::de::Error>::duplicate_field(
494                                            "footRaisedAnkleHeightMS",
495                                        ),
496                                    );
497                                }
498                                m_footRaisedAnkleHeightMS = _serde::__private::Some(
499                                    match __A::next_value::<f32>(&mut __map) {
500                                        _serde::__private::Ok(__val) => __val,
501                                        _serde::__private::Err(__err) => {
502                                            return _serde::__private::Err(__err);
503                                        }
504                                    },
505                                );
506                            }
507                            7usize => {
508                                if _serde::__private::Option::is_some(&m_maxAnkleHeightMS) {
509                                    return _serde::__private::Err(
510                                        <__A::Error as _serde::de::Error>::duplicate_field(
511                                            "maxAnkleHeightMS",
512                                        ),
513                                    );
514                                }
515                                m_maxAnkleHeightMS = _serde::__private::Some(
516                                    match __A::next_value::<f32>(&mut __map) {
517                                        _serde::__private::Ok(__val) => __val,
518                                        _serde::__private::Err(__err) => {
519                                            return _serde::__private::Err(__err);
520                                        }
521                                    },
522                                );
523                            }
524                            8usize => {
525                                if _serde::__private::Option::is_some(&m_minAnkleHeightMS) {
526                                    return _serde::__private::Err(
527                                        <__A::Error as _serde::de::Error>::duplicate_field(
528                                            "minAnkleHeightMS",
529                                        ),
530                                    );
531                                }
532                                m_minAnkleHeightMS = _serde::__private::Some(
533                                    match __A::next_value::<f32>(&mut __map) {
534                                        _serde::__private::Ok(__val) => __val,
535                                        _serde::__private::Err(__err) => {
536                                            return _serde::__private::Err(__err);
537                                        }
538                                    },
539                                );
540                            }
541                            9usize => {
542                                if _serde::__private::Option::is_some(
543                                    &m_maxKneeAngleDegrees,
544                                ) {
545                                    return _serde::__private::Err(
546                                        <__A::Error as _serde::de::Error>::duplicate_field(
547                                            "maxKneeAngleDegrees",
548                                        ),
549                                    );
550                                }
551                                m_maxKneeAngleDegrees = _serde::__private::Some(
552                                    match __A::next_value::<f32>(&mut __map) {
553                                        _serde::__private::Ok(__val) => __val,
554                                        _serde::__private::Err(__err) => {
555                                            return _serde::__private::Err(__err);
556                                        }
557                                    },
558                                );
559                            }
560                            10usize => {
561                                if _serde::__private::Option::is_some(
562                                    &m_minKneeAngleDegrees,
563                                ) {
564                                    return _serde::__private::Err(
565                                        <__A::Error as _serde::de::Error>::duplicate_field(
566                                            "minKneeAngleDegrees",
567                                        ),
568                                    );
569                                }
570                                m_minKneeAngleDegrees = _serde::__private::Some(
571                                    match __A::next_value::<f32>(&mut __map) {
572                                        _serde::__private::Ok(__val) => __val,
573                                        _serde::__private::Err(__err) => {
574                                            return _serde::__private::Err(__err);
575                                        }
576                                    },
577                                );
578                            }
579                            11usize => {
580                                if _serde::__private::Option::is_some(&m_verticalError) {
581                                    return _serde::__private::Err(
582                                        <__A::Error as _serde::de::Error>::duplicate_field(
583                                            "verticalError",
584                                        ),
585                                    );
586                                }
587                                m_verticalError = _serde::__private::Some(
588                                    match __A::next_value::<f32>(&mut __map) {
589                                        _serde::__private::Ok(__val) => __val,
590                                        _serde::__private::Err(__err) => {
591                                            return _serde::__private::Err(__err);
592                                        }
593                                    },
594                                );
595                            }
596                            12usize => {
597                                if _serde::__private::Option::is_some(
598                                    &m_maxAnkleAngleDegrees,
599                                ) {
600                                    return _serde::__private::Err(
601                                        <__A::Error as _serde::de::Error>::duplicate_field(
602                                            "maxAnkleAngleDegrees",
603                                        ),
604                                    );
605                                }
606                                m_maxAnkleAngleDegrees = _serde::__private::Some(
607                                    match __A::next_value::<f32>(&mut __map) {
608                                        _serde::__private::Ok(__val) => __val,
609                                        _serde::__private::Err(__err) => {
610                                            return _serde::__private::Err(__err);
611                                        }
612                                    },
613                                );
614                            }
615                            13usize => {
616                                if _serde::__private::Option::is_some(&m_hipIndex) {
617                                    return _serde::__private::Err(
618                                        <__A::Error as _serde::de::Error>::duplicate_field(
619                                            "hipIndex",
620                                        ),
621                                    );
622                                }
623                                m_hipIndex = _serde::__private::Some(
624                                    match __A::next_value::<i16>(&mut __map) {
625                                        _serde::__private::Ok(__val) => __val,
626                                        _serde::__private::Err(__err) => {
627                                            return _serde::__private::Err(__err);
628                                        }
629                                    },
630                                );
631                            }
632                            14usize => {
633                                if _serde::__private::Option::is_some(&m_kneeIndex) {
634                                    return _serde::__private::Err(
635                                        <__A::Error as _serde::de::Error>::duplicate_field(
636                                            "kneeIndex",
637                                        ),
638                                    );
639                                }
640                                m_kneeIndex = _serde::__private::Some(
641                                    match __A::next_value::<i16>(&mut __map) {
642                                        _serde::__private::Ok(__val) => __val,
643                                        _serde::__private::Err(__err) => {
644                                            return _serde::__private::Err(__err);
645                                        }
646                                    },
647                                );
648                            }
649                            15usize => {
650                                if _serde::__private::Option::is_some(&m_ankleIndex) {
651                                    return _serde::__private::Err(
652                                        <__A::Error as _serde::de::Error>::duplicate_field(
653                                            "ankleIndex",
654                                        ),
655                                    );
656                                }
657                                m_ankleIndex = _serde::__private::Some(
658                                    match __A::next_value::<i16>(&mut __map) {
659                                        _serde::__private::Ok(__val) => __val,
660                                        _serde::__private::Err(__err) => {
661                                            return _serde::__private::Err(__err);
662                                        }
663                                    },
664                                );
665                            }
666                            16usize => {
667                                if _serde::__private::Option::is_some(&m_hitSomething) {
668                                    return _serde::__private::Err(
669                                        <__A::Error as _serde::de::Error>::duplicate_field(
670                                            "hitSomething",
671                                        ),
672                                    );
673                                }
674                                m_hitSomething = _serde::__private::Some(
675                                    match __A::next_value::<bool>(&mut __map) {
676                                        _serde::__private::Ok(__val) => __val,
677                                        _serde::__private::Err(__err) => {
678                                            return _serde::__private::Err(__err);
679                                        }
680                                    },
681                                );
682                            }
683                            17usize => {
684                                if _serde::__private::Option::is_some(&m_isPlantedMS) {
685                                    return _serde::__private::Err(
686                                        <__A::Error as _serde::de::Error>::duplicate_field(
687                                            "isPlantedMS",
688                                        ),
689                                    );
690                                }
691                                m_isPlantedMS = _serde::__private::Some(
692                                    match __A::next_value::<bool>(&mut __map) {
693                                        _serde::__private::Ok(__val) => __val,
694                                        _serde::__private::Err(__err) => {
695                                            return _serde::__private::Err(__err);
696                                        }
697                                    },
698                                );
699                            }
700                            18usize => {
701                                if _serde::__private::Option::is_some(
702                                    &m_isOriginalAnkleTransformMSSet,
703                                ) {
704                                    return _serde::__private::Err(
705                                        <__A::Error as _serde::de::Error>::duplicate_field(
706                                            "isOriginalAnkleTransformMSSet",
707                                        ),
708                                    );
709                                }
710                                m_isOriginalAnkleTransformMSSet = _serde::__private::Some(
711                                    match __A::next_value::<bool>(&mut __map) {
712                                        _serde::__private::Ok(__val) => __val,
713                                        _serde::__private::Err(__err) => {
714                                            return _serde::__private::Err(__err);
715                                        }
716                                    },
717                                );
718                            }
719                            _ => {}
720                        }
721                    }
722                    __A::pad(&mut __map, 15usize, 7usize)?;
723                    let m_originalAnkleTransformMS = match m_originalAnkleTransformMS {
724                        _serde::__private::Some(__field) => __field,
725                        _serde::__private::None => {
726                            return _serde::__private::Err(
727                                <__A::Error as _serde::de::Error>::missing_field(
728                                    "originalAnkleTransformMS",
729                                ),
730                            );
731                        }
732                    };
733                    let m_prevAnkleRotLS = match m_prevAnkleRotLS {
734                        _serde::__private::Some(__field) => __field,
735                        _serde::__private::None => {
736                            return _serde::__private::Err(
737                                <__A::Error as _serde::de::Error>::missing_field(
738                                    "prevAnkleRotLS",
739                                ),
740                            );
741                        }
742                    };
743                    let m_kneeAxisLS = match m_kneeAxisLS {
744                        _serde::__private::Some(__field) => __field,
745                        _serde::__private::None => {
746                            return _serde::__private::Err(
747                                <__A::Error as _serde::de::Error>::missing_field(
748                                    "kneeAxisLS",
749                                ),
750                            );
751                        }
752                    };
753                    let m_footEndLS = match m_footEndLS {
754                        _serde::__private::Some(__field) => __field,
755                        _serde::__private::None => {
756                            return _serde::__private::Err(
757                                <__A::Error as _serde::de::Error>::missing_field(
758                                    "footEndLS",
759                                ),
760                            );
761                        }
762                    };
763                    let m_ungroundedEvent = match m_ungroundedEvent {
764                        _serde::__private::Some(__field) => __field,
765                        _serde::__private::None => {
766                            return _serde::__private::Err(
767                                <__A::Error as _serde::de::Error>::missing_field(
768                                    "ungroundedEvent",
769                                ),
770                            );
771                        }
772                    };
773                    let m_footPlantedAnkleHeightMS = match m_footPlantedAnkleHeightMS {
774                        _serde::__private::Some(__field) => __field,
775                        _serde::__private::None => {
776                            return _serde::__private::Err(
777                                <__A::Error as _serde::de::Error>::missing_field(
778                                    "footPlantedAnkleHeightMS",
779                                ),
780                            );
781                        }
782                    };
783                    let m_footRaisedAnkleHeightMS = match m_footRaisedAnkleHeightMS {
784                        _serde::__private::Some(__field) => __field,
785                        _serde::__private::None => {
786                            return _serde::__private::Err(
787                                <__A::Error as _serde::de::Error>::missing_field(
788                                    "footRaisedAnkleHeightMS",
789                                ),
790                            );
791                        }
792                    };
793                    let m_maxAnkleHeightMS = match m_maxAnkleHeightMS {
794                        _serde::__private::Some(__field) => __field,
795                        _serde::__private::None => {
796                            return _serde::__private::Err(
797                                <__A::Error as _serde::de::Error>::missing_field(
798                                    "maxAnkleHeightMS",
799                                ),
800                            );
801                        }
802                    };
803                    let m_minAnkleHeightMS = match m_minAnkleHeightMS {
804                        _serde::__private::Some(__field) => __field,
805                        _serde::__private::None => {
806                            return _serde::__private::Err(
807                                <__A::Error as _serde::de::Error>::missing_field(
808                                    "minAnkleHeightMS",
809                                ),
810                            );
811                        }
812                    };
813                    let m_maxKneeAngleDegrees = match m_maxKneeAngleDegrees {
814                        _serde::__private::Some(__field) => __field,
815                        _serde::__private::None => {
816                            return _serde::__private::Err(
817                                <__A::Error as _serde::de::Error>::missing_field(
818                                    "maxKneeAngleDegrees",
819                                ),
820                            );
821                        }
822                    };
823                    let m_minKneeAngleDegrees = match m_minKneeAngleDegrees {
824                        _serde::__private::Some(__field) => __field,
825                        _serde::__private::None => {
826                            return _serde::__private::Err(
827                                <__A::Error as _serde::de::Error>::missing_field(
828                                    "minKneeAngleDegrees",
829                                ),
830                            );
831                        }
832                    };
833                    let m_verticalError = match m_verticalError {
834                        _serde::__private::Some(__field) => __field,
835                        _serde::__private::None => {
836                            return _serde::__private::Err(
837                                <__A::Error as _serde::de::Error>::missing_field(
838                                    "verticalError",
839                                ),
840                            );
841                        }
842                    };
843                    let m_maxAnkleAngleDegrees = match m_maxAnkleAngleDegrees {
844                        _serde::__private::Some(__field) => __field,
845                        _serde::__private::None => {
846                            return _serde::__private::Err(
847                                <__A::Error as _serde::de::Error>::missing_field(
848                                    "maxAnkleAngleDegrees",
849                                ),
850                            );
851                        }
852                    };
853                    let m_hipIndex = match m_hipIndex {
854                        _serde::__private::Some(__field) => __field,
855                        _serde::__private::None => {
856                            return _serde::__private::Err(
857                                <__A::Error as _serde::de::Error>::missing_field("hipIndex"),
858                            );
859                        }
860                    };
861                    let m_kneeIndex = match m_kneeIndex {
862                        _serde::__private::Some(__field) => __field,
863                        _serde::__private::None => {
864                            return _serde::__private::Err(
865                                <__A::Error as _serde::de::Error>::missing_field(
866                                    "kneeIndex",
867                                ),
868                            );
869                        }
870                    };
871                    let m_ankleIndex = match m_ankleIndex {
872                        _serde::__private::Some(__field) => __field,
873                        _serde::__private::None => {
874                            return _serde::__private::Err(
875                                <__A::Error as _serde::de::Error>::missing_field(
876                                    "ankleIndex",
877                                ),
878                            );
879                        }
880                    };
881                    let m_hitSomething = match m_hitSomething {
882                        _serde::__private::Some(__field) => __field,
883                        _serde::__private::None => {
884                            return _serde::__private::Err(
885                                <__A::Error as _serde::de::Error>::missing_field(
886                                    "hitSomething",
887                                ),
888                            );
889                        }
890                    };
891                    let m_isPlantedMS = match m_isPlantedMS {
892                        _serde::__private::Some(__field) => __field,
893                        _serde::__private::None => {
894                            return _serde::__private::Err(
895                                <__A::Error as _serde::de::Error>::missing_field(
896                                    "isPlantedMS",
897                                ),
898                            );
899                        }
900                    };
901                    let m_isOriginalAnkleTransformMSSet = match m_isOriginalAnkleTransformMSSet {
902                        _serde::__private::Some(__field) => __field,
903                        _serde::__private::None => {
904                            return _serde::__private::Err(
905                                <__A::Error as _serde::de::Error>::missing_field(
906                                    "isOriginalAnkleTransformMSSet",
907                                ),
908                            );
909                        }
910                    };
911                    _serde::__private::Ok(hkbFootIkModifierLeg {
912                        __ptr,
913                        m_originalAnkleTransformMS,
914                        m_prevAnkleRotLS,
915                        m_kneeAxisLS,
916                        m_footEndLS,
917                        m_ungroundedEvent,
918                        m_footPlantedAnkleHeightMS,
919                        m_footRaisedAnkleHeightMS,
920                        m_maxAnkleHeightMS,
921                        m_minAnkleHeightMS,
922                        m_maxKneeAngleDegrees,
923                        m_minKneeAngleDegrees,
924                        m_verticalError,
925                        m_maxAnkleAngleDegrees,
926                        m_hipIndex,
927                        m_kneeIndex,
928                        m_ankleIndex,
929                        m_hitSomething,
930                        m_isPlantedMS,
931                        m_isOriginalAnkleTransformMSSet,
932                    })
933                }
934                #[allow(clippy::manual_unwrap_or_default)]
935                fn visit_struct<__A>(
936                    self,
937                    mut __map: __A,
938                ) -> _serde::__private::Result<Self::Value, __A::Error>
939                where
940                    __A: _serde::de::MapAccess<'de>,
941                {
942                    let mut m_originalAnkleTransformMS: _serde::__private::Option<
943                        QsTransform,
944                    > = _serde::__private::None;
945                    let mut m_kneeAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
946                    let mut m_footEndLS: _serde::__private::Option<Vector4> = _serde::__private::None;
947                    let mut m_ungroundedEvent: _serde::__private::Option<
948                        hkbEventProperty,
949                    > = _serde::__private::None;
950                    let mut m_footPlantedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
951                    let mut m_footRaisedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
952                    let mut m_maxAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
953                    let mut m_minAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
954                    let mut m_maxKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
955                    let mut m_minKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
956                    let mut m_verticalError: _serde::__private::Option<f32> = _serde::__private::None;
957                    let mut m_maxAnkleAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
958                    let mut m_hipIndex: _serde::__private::Option<i16> = _serde::__private::None;
959                    let mut m_kneeIndex: _serde::__private::Option<i16> = _serde::__private::None;
960                    let mut m_ankleIndex: _serde::__private::Option<i16> = _serde::__private::None;
961                    let mut m_hitSomething: _serde::__private::Option<bool> = _serde::__private::None;
962                    let mut m_isPlantedMS: _serde::__private::Option<bool> = _serde::__private::None;
963                    let mut m_isOriginalAnkleTransformMSSet: _serde::__private::Option<
964                        bool,
965                    > = _serde::__private::None;
966                    while let _serde::__private::Some(__key) = {
967                        __A::next_key::<__Field>(&mut __map)?
968                    } {
969                        match __key {
970                            __Field::m_originalAnkleTransformMS => {
971                                #[cfg(
972                                    any(feature = "strict", feature = "ignore_duplicates")
973                                )]
974                                if _serde::__private::Option::is_some(
975                                    &m_originalAnkleTransformMS,
976                                ) {
977                                    #[cfg(feature = "ignore_duplicates")]
978                                    {
979                                        __A::skip_value(&mut __map)?;
980                                        continue;
981                                    }
982                                    #[cfg(feature = "strict")]
983                                    return _serde::__private::Err(
984                                        <__A::Error as _serde::de::Error>::duplicate_field(
985                                            "originalAnkleTransformMS",
986                                        ),
987                                    );
988                                }
989                                m_originalAnkleTransformMS = _serde::__private::Some(
990                                    match __A::next_value::<QsTransform>(&mut __map) {
991                                        _serde::__private::Ok(__val) => __val,
992                                        _serde::__private::Err(__err) => {
993                                            return _serde::__private::Err(__err);
994                                        }
995                                    },
996                                );
997                            }
998                            __Field::m_kneeAxisLS => {
999                                #[cfg(
1000                                    any(feature = "strict", feature = "ignore_duplicates")
1001                                )]
1002                                if _serde::__private::Option::is_some(&m_kneeAxisLS) {
1003                                    #[cfg(feature = "ignore_duplicates")]
1004                                    {
1005                                        __A::skip_value(&mut __map)?;
1006                                        continue;
1007                                    }
1008                                    #[cfg(feature = "strict")]
1009                                    return _serde::__private::Err(
1010                                        <__A::Error as _serde::de::Error>::duplicate_field(
1011                                            "kneeAxisLS",
1012                                        ),
1013                                    );
1014                                }
1015                                m_kneeAxisLS = _serde::__private::Some(
1016                                    match __A::next_value::<Vector4>(&mut __map) {
1017                                        _serde::__private::Ok(__val) => __val,
1018                                        _serde::__private::Err(__err) => {
1019                                            return _serde::__private::Err(__err);
1020                                        }
1021                                    },
1022                                );
1023                            }
1024                            __Field::m_footEndLS => {
1025                                #[cfg(
1026                                    any(feature = "strict", feature = "ignore_duplicates")
1027                                )]
1028                                if _serde::__private::Option::is_some(&m_footEndLS) {
1029                                    #[cfg(feature = "ignore_duplicates")]
1030                                    {
1031                                        __A::skip_value(&mut __map)?;
1032                                        continue;
1033                                    }
1034                                    #[cfg(feature = "strict")]
1035                                    return _serde::__private::Err(
1036                                        <__A::Error as _serde::de::Error>::duplicate_field(
1037                                            "footEndLS",
1038                                        ),
1039                                    );
1040                                }
1041                                m_footEndLS = _serde::__private::Some(
1042                                    match __A::next_value::<Vector4>(&mut __map) {
1043                                        _serde::__private::Ok(__val) => __val,
1044                                        _serde::__private::Err(__err) => {
1045                                            return _serde::__private::Err(__err);
1046                                        }
1047                                    },
1048                                );
1049                            }
1050                            __Field::m_ungroundedEvent => {
1051                                #[cfg(
1052                                    any(feature = "strict", feature = "ignore_duplicates")
1053                                )]
1054                                if _serde::__private::Option::is_some(&m_ungroundedEvent) {
1055                                    #[cfg(feature = "ignore_duplicates")]
1056                                    {
1057                                        __A::skip_value(&mut __map)?;
1058                                        continue;
1059                                    }
1060                                    #[cfg(feature = "strict")]
1061                                    return _serde::__private::Err(
1062                                        <__A::Error as _serde::de::Error>::duplicate_field(
1063                                            "ungroundedEvent",
1064                                        ),
1065                                    );
1066                                }
1067                                m_ungroundedEvent = _serde::__private::Some(
1068                                    match __A::next_value::<hkbEventProperty>(&mut __map) {
1069                                        _serde::__private::Ok(__val) => __val,
1070                                        _serde::__private::Err(__err) => {
1071                                            return _serde::__private::Err(__err);
1072                                        }
1073                                    },
1074                                );
1075                            }
1076                            __Field::m_footPlantedAnkleHeightMS => {
1077                                #[cfg(
1078                                    any(feature = "strict", feature = "ignore_duplicates")
1079                                )]
1080                                if _serde::__private::Option::is_some(
1081                                    &m_footPlantedAnkleHeightMS,
1082                                ) {
1083                                    #[cfg(feature = "ignore_duplicates")]
1084                                    {
1085                                        __A::skip_value(&mut __map)?;
1086                                        continue;
1087                                    }
1088                                    #[cfg(feature = "strict")]
1089                                    return _serde::__private::Err(
1090                                        <__A::Error as _serde::de::Error>::duplicate_field(
1091                                            "footPlantedAnkleHeightMS",
1092                                        ),
1093                                    );
1094                                }
1095                                m_footPlantedAnkleHeightMS = _serde::__private::Some(
1096                                    match __A::next_value::<f32>(&mut __map) {
1097                                        _serde::__private::Ok(__val) => __val,
1098                                        _serde::__private::Err(__err) => {
1099                                            return _serde::__private::Err(__err);
1100                                        }
1101                                    },
1102                                );
1103                            }
1104                            __Field::m_footRaisedAnkleHeightMS => {
1105                                #[cfg(
1106                                    any(feature = "strict", feature = "ignore_duplicates")
1107                                )]
1108                                if _serde::__private::Option::is_some(
1109                                    &m_footRaisedAnkleHeightMS,
1110                                ) {
1111                                    #[cfg(feature = "ignore_duplicates")]
1112                                    {
1113                                        __A::skip_value(&mut __map)?;
1114                                        continue;
1115                                    }
1116                                    #[cfg(feature = "strict")]
1117                                    return _serde::__private::Err(
1118                                        <__A::Error as _serde::de::Error>::duplicate_field(
1119                                            "footRaisedAnkleHeightMS",
1120                                        ),
1121                                    );
1122                                }
1123                                m_footRaisedAnkleHeightMS = _serde::__private::Some(
1124                                    match __A::next_value::<f32>(&mut __map) {
1125                                        _serde::__private::Ok(__val) => __val,
1126                                        _serde::__private::Err(__err) => {
1127                                            return _serde::__private::Err(__err);
1128                                        }
1129                                    },
1130                                );
1131                            }
1132                            __Field::m_maxAnkleHeightMS => {
1133                                #[cfg(
1134                                    any(feature = "strict", feature = "ignore_duplicates")
1135                                )]
1136                                if _serde::__private::Option::is_some(&m_maxAnkleHeightMS) {
1137                                    #[cfg(feature = "ignore_duplicates")]
1138                                    {
1139                                        __A::skip_value(&mut __map)?;
1140                                        continue;
1141                                    }
1142                                    #[cfg(feature = "strict")]
1143                                    return _serde::__private::Err(
1144                                        <__A::Error as _serde::de::Error>::duplicate_field(
1145                                            "maxAnkleHeightMS",
1146                                        ),
1147                                    );
1148                                }
1149                                m_maxAnkleHeightMS = _serde::__private::Some(
1150                                    match __A::next_value::<f32>(&mut __map) {
1151                                        _serde::__private::Ok(__val) => __val,
1152                                        _serde::__private::Err(__err) => {
1153                                            return _serde::__private::Err(__err);
1154                                        }
1155                                    },
1156                                );
1157                            }
1158                            __Field::m_minAnkleHeightMS => {
1159                                #[cfg(
1160                                    any(feature = "strict", feature = "ignore_duplicates")
1161                                )]
1162                                if _serde::__private::Option::is_some(&m_minAnkleHeightMS) {
1163                                    #[cfg(feature = "ignore_duplicates")]
1164                                    {
1165                                        __A::skip_value(&mut __map)?;
1166                                        continue;
1167                                    }
1168                                    #[cfg(feature = "strict")]
1169                                    return _serde::__private::Err(
1170                                        <__A::Error as _serde::de::Error>::duplicate_field(
1171                                            "minAnkleHeightMS",
1172                                        ),
1173                                    );
1174                                }
1175                                m_minAnkleHeightMS = _serde::__private::Some(
1176                                    match __A::next_value::<f32>(&mut __map) {
1177                                        _serde::__private::Ok(__val) => __val,
1178                                        _serde::__private::Err(__err) => {
1179                                            return _serde::__private::Err(__err);
1180                                        }
1181                                    },
1182                                );
1183                            }
1184                            __Field::m_maxKneeAngleDegrees => {
1185                                #[cfg(
1186                                    any(feature = "strict", feature = "ignore_duplicates")
1187                                )]
1188                                if _serde::__private::Option::is_some(
1189                                    &m_maxKneeAngleDegrees,
1190                                ) {
1191                                    #[cfg(feature = "ignore_duplicates")]
1192                                    {
1193                                        __A::skip_value(&mut __map)?;
1194                                        continue;
1195                                    }
1196                                    #[cfg(feature = "strict")]
1197                                    return _serde::__private::Err(
1198                                        <__A::Error as _serde::de::Error>::duplicate_field(
1199                                            "maxKneeAngleDegrees",
1200                                        ),
1201                                    );
1202                                }
1203                                m_maxKneeAngleDegrees = _serde::__private::Some(
1204                                    match __A::next_value::<f32>(&mut __map) {
1205                                        _serde::__private::Ok(__val) => __val,
1206                                        _serde::__private::Err(__err) => {
1207                                            return _serde::__private::Err(__err);
1208                                        }
1209                                    },
1210                                );
1211                            }
1212                            __Field::m_minKneeAngleDegrees => {
1213                                #[cfg(
1214                                    any(feature = "strict", feature = "ignore_duplicates")
1215                                )]
1216                                if _serde::__private::Option::is_some(
1217                                    &m_minKneeAngleDegrees,
1218                                ) {
1219                                    #[cfg(feature = "ignore_duplicates")]
1220                                    {
1221                                        __A::skip_value(&mut __map)?;
1222                                        continue;
1223                                    }
1224                                    #[cfg(feature = "strict")]
1225                                    return _serde::__private::Err(
1226                                        <__A::Error as _serde::de::Error>::duplicate_field(
1227                                            "minKneeAngleDegrees",
1228                                        ),
1229                                    );
1230                                }
1231                                m_minKneeAngleDegrees = _serde::__private::Some(
1232                                    match __A::next_value::<f32>(&mut __map) {
1233                                        _serde::__private::Ok(__val) => __val,
1234                                        _serde::__private::Err(__err) => {
1235                                            return _serde::__private::Err(__err);
1236                                        }
1237                                    },
1238                                );
1239                            }
1240                            __Field::m_verticalError => {
1241                                #[cfg(
1242                                    any(feature = "strict", feature = "ignore_duplicates")
1243                                )]
1244                                if _serde::__private::Option::is_some(&m_verticalError) {
1245                                    #[cfg(feature = "ignore_duplicates")]
1246                                    {
1247                                        __A::skip_value(&mut __map)?;
1248                                        continue;
1249                                    }
1250                                    #[cfg(feature = "strict")]
1251                                    return _serde::__private::Err(
1252                                        <__A::Error as _serde::de::Error>::duplicate_field(
1253                                            "verticalError",
1254                                        ),
1255                                    );
1256                                }
1257                                m_verticalError = _serde::__private::Some(
1258                                    match __A::next_value::<f32>(&mut __map) {
1259                                        _serde::__private::Ok(__val) => __val,
1260                                        _serde::__private::Err(__err) => {
1261                                            return _serde::__private::Err(__err);
1262                                        }
1263                                    },
1264                                );
1265                            }
1266                            __Field::m_maxAnkleAngleDegrees => {
1267                                #[cfg(
1268                                    any(feature = "strict", feature = "ignore_duplicates")
1269                                )]
1270                                if _serde::__private::Option::is_some(
1271                                    &m_maxAnkleAngleDegrees,
1272                                ) {
1273                                    #[cfg(feature = "ignore_duplicates")]
1274                                    {
1275                                        __A::skip_value(&mut __map)?;
1276                                        continue;
1277                                    }
1278                                    #[cfg(feature = "strict")]
1279                                    return _serde::__private::Err(
1280                                        <__A::Error as _serde::de::Error>::duplicate_field(
1281                                            "maxAnkleAngleDegrees",
1282                                        ),
1283                                    );
1284                                }
1285                                m_maxAnkleAngleDegrees = _serde::__private::Some(
1286                                    match __A::next_value::<f32>(&mut __map) {
1287                                        _serde::__private::Ok(__val) => __val,
1288                                        _serde::__private::Err(__err) => {
1289                                            return _serde::__private::Err(__err);
1290                                        }
1291                                    },
1292                                );
1293                            }
1294                            __Field::m_hipIndex => {
1295                                #[cfg(
1296                                    any(feature = "strict", feature = "ignore_duplicates")
1297                                )]
1298                                if _serde::__private::Option::is_some(&m_hipIndex) {
1299                                    #[cfg(feature = "ignore_duplicates")]
1300                                    {
1301                                        __A::skip_value(&mut __map)?;
1302                                        continue;
1303                                    }
1304                                    #[cfg(feature = "strict")]
1305                                    return _serde::__private::Err(
1306                                        <__A::Error as _serde::de::Error>::duplicate_field(
1307                                            "hipIndex",
1308                                        ),
1309                                    );
1310                                }
1311                                m_hipIndex = _serde::__private::Some(
1312                                    match __A::next_value::<i16>(&mut __map) {
1313                                        _serde::__private::Ok(__val) => __val,
1314                                        _serde::__private::Err(__err) => {
1315                                            return _serde::__private::Err(__err);
1316                                        }
1317                                    },
1318                                );
1319                            }
1320                            __Field::m_kneeIndex => {
1321                                #[cfg(
1322                                    any(feature = "strict", feature = "ignore_duplicates")
1323                                )]
1324                                if _serde::__private::Option::is_some(&m_kneeIndex) {
1325                                    #[cfg(feature = "ignore_duplicates")]
1326                                    {
1327                                        __A::skip_value(&mut __map)?;
1328                                        continue;
1329                                    }
1330                                    #[cfg(feature = "strict")]
1331                                    return _serde::__private::Err(
1332                                        <__A::Error as _serde::de::Error>::duplicate_field(
1333                                            "kneeIndex",
1334                                        ),
1335                                    );
1336                                }
1337                                m_kneeIndex = _serde::__private::Some(
1338                                    match __A::next_value::<i16>(&mut __map) {
1339                                        _serde::__private::Ok(__val) => __val,
1340                                        _serde::__private::Err(__err) => {
1341                                            return _serde::__private::Err(__err);
1342                                        }
1343                                    },
1344                                );
1345                            }
1346                            __Field::m_ankleIndex => {
1347                                #[cfg(
1348                                    any(feature = "strict", feature = "ignore_duplicates")
1349                                )]
1350                                if _serde::__private::Option::is_some(&m_ankleIndex) {
1351                                    #[cfg(feature = "ignore_duplicates")]
1352                                    {
1353                                        __A::skip_value(&mut __map)?;
1354                                        continue;
1355                                    }
1356                                    #[cfg(feature = "strict")]
1357                                    return _serde::__private::Err(
1358                                        <__A::Error as _serde::de::Error>::duplicate_field(
1359                                            "ankleIndex",
1360                                        ),
1361                                    );
1362                                }
1363                                m_ankleIndex = _serde::__private::Some(
1364                                    match __A::next_value::<i16>(&mut __map) {
1365                                        _serde::__private::Ok(__val) => __val,
1366                                        _serde::__private::Err(__err) => {
1367                                            return _serde::__private::Err(__err);
1368                                        }
1369                                    },
1370                                );
1371                            }
1372                            __Field::m_hitSomething => {
1373                                #[cfg(
1374                                    any(feature = "strict", feature = "ignore_duplicates")
1375                                )]
1376                                if _serde::__private::Option::is_some(&m_hitSomething) {
1377                                    #[cfg(feature = "ignore_duplicates")]
1378                                    {
1379                                        __A::skip_value(&mut __map)?;
1380                                        continue;
1381                                    }
1382                                    #[cfg(feature = "strict")]
1383                                    return _serde::__private::Err(
1384                                        <__A::Error as _serde::de::Error>::duplicate_field(
1385                                            "hitSomething",
1386                                        ),
1387                                    );
1388                                }
1389                                m_hitSomething = _serde::__private::Some(
1390                                    match __A::next_value::<bool>(&mut __map) {
1391                                        _serde::__private::Ok(__val) => __val,
1392                                        _serde::__private::Err(__err) => {
1393                                            return _serde::__private::Err(__err);
1394                                        }
1395                                    },
1396                                );
1397                            }
1398                            __Field::m_isPlantedMS => {
1399                                #[cfg(
1400                                    any(feature = "strict", feature = "ignore_duplicates")
1401                                )]
1402                                if _serde::__private::Option::is_some(&m_isPlantedMS) {
1403                                    #[cfg(feature = "ignore_duplicates")]
1404                                    {
1405                                        __A::skip_value(&mut __map)?;
1406                                        continue;
1407                                    }
1408                                    #[cfg(feature = "strict")]
1409                                    return _serde::__private::Err(
1410                                        <__A::Error as _serde::de::Error>::duplicate_field(
1411                                            "isPlantedMS",
1412                                        ),
1413                                    );
1414                                }
1415                                m_isPlantedMS = _serde::__private::Some(
1416                                    match __A::next_value::<bool>(&mut __map) {
1417                                        _serde::__private::Ok(__val) => __val,
1418                                        _serde::__private::Err(__err) => {
1419                                            return _serde::__private::Err(__err);
1420                                        }
1421                                    },
1422                                );
1423                            }
1424                            __Field::m_isOriginalAnkleTransformMSSet => {
1425                                #[cfg(
1426                                    any(feature = "strict", feature = "ignore_duplicates")
1427                                )]
1428                                if _serde::__private::Option::is_some(
1429                                    &m_isOriginalAnkleTransformMSSet,
1430                                ) {
1431                                    #[cfg(feature = "ignore_duplicates")]
1432                                    {
1433                                        __A::skip_value(&mut __map)?;
1434                                        continue;
1435                                    }
1436                                    #[cfg(feature = "strict")]
1437                                    return _serde::__private::Err(
1438                                        <__A::Error as _serde::de::Error>::duplicate_field(
1439                                            "isOriginalAnkleTransformMSSet",
1440                                        ),
1441                                    );
1442                                }
1443                                m_isOriginalAnkleTransformMSSet = _serde::__private::Some(
1444                                    match __A::next_value::<bool>(&mut __map) {
1445                                        _serde::__private::Ok(__val) => __val,
1446                                        _serde::__private::Err(__err) => {
1447                                            return _serde::__private::Err(__err);
1448                                        }
1449                                    },
1450                                );
1451                            }
1452                            _ => __A::skip_value(&mut __map)?,
1453                        }
1454                    }
1455                    let m_originalAnkleTransformMS = match m_originalAnkleTransformMS {
1456                        _serde::__private::Some(__field) => __field,
1457                        _serde::__private::None => {
1458                            #[cfg(feature = "strict")]
1459                            return _serde::__private::Err(
1460                                <__A::Error as _serde::de::Error>::missing_field(
1461                                    "originalAnkleTransformMS",
1462                                ),
1463                            );
1464                            #[cfg(not(feature = "strict"))] Default::default()
1465                        }
1466                    };
1467                    let m_kneeAxisLS = match m_kneeAxisLS {
1468                        _serde::__private::Some(__field) => __field,
1469                        _serde::__private::None => {
1470                            #[cfg(feature = "strict")]
1471                            return _serde::__private::Err(
1472                                <__A::Error as _serde::de::Error>::missing_field(
1473                                    "kneeAxisLS",
1474                                ),
1475                            );
1476                            #[cfg(not(feature = "strict"))] Default::default()
1477                        }
1478                    };
1479                    let m_footEndLS = match m_footEndLS {
1480                        _serde::__private::Some(__field) => __field,
1481                        _serde::__private::None => {
1482                            #[cfg(feature = "strict")]
1483                            return _serde::__private::Err(
1484                                <__A::Error as _serde::de::Error>::missing_field(
1485                                    "footEndLS",
1486                                ),
1487                            );
1488                            #[cfg(not(feature = "strict"))] Default::default()
1489                        }
1490                    };
1491                    let m_ungroundedEvent = match m_ungroundedEvent {
1492                        _serde::__private::Some(__field) => __field,
1493                        _serde::__private::None => {
1494                            #[cfg(feature = "strict")]
1495                            return _serde::__private::Err(
1496                                <__A::Error as _serde::de::Error>::missing_field(
1497                                    "ungroundedEvent",
1498                                ),
1499                            );
1500                            #[cfg(not(feature = "strict"))] Default::default()
1501                        }
1502                    };
1503                    let m_footPlantedAnkleHeightMS = match m_footPlantedAnkleHeightMS {
1504                        _serde::__private::Some(__field) => __field,
1505                        _serde::__private::None => {
1506                            #[cfg(feature = "strict")]
1507                            return _serde::__private::Err(
1508                                <__A::Error as _serde::de::Error>::missing_field(
1509                                    "footPlantedAnkleHeightMS",
1510                                ),
1511                            );
1512                            #[cfg(not(feature = "strict"))] Default::default()
1513                        }
1514                    };
1515                    let m_footRaisedAnkleHeightMS = match m_footRaisedAnkleHeightMS {
1516                        _serde::__private::Some(__field) => __field,
1517                        _serde::__private::None => {
1518                            #[cfg(feature = "strict")]
1519                            return _serde::__private::Err(
1520                                <__A::Error as _serde::de::Error>::missing_field(
1521                                    "footRaisedAnkleHeightMS",
1522                                ),
1523                            );
1524                            #[cfg(not(feature = "strict"))] Default::default()
1525                        }
1526                    };
1527                    let m_maxAnkleHeightMS = match m_maxAnkleHeightMS {
1528                        _serde::__private::Some(__field) => __field,
1529                        _serde::__private::None => {
1530                            #[cfg(feature = "strict")]
1531                            return _serde::__private::Err(
1532                                <__A::Error as _serde::de::Error>::missing_field(
1533                                    "maxAnkleHeightMS",
1534                                ),
1535                            );
1536                            #[cfg(not(feature = "strict"))] Default::default()
1537                        }
1538                    };
1539                    let m_minAnkleHeightMS = match m_minAnkleHeightMS {
1540                        _serde::__private::Some(__field) => __field,
1541                        _serde::__private::None => {
1542                            #[cfg(feature = "strict")]
1543                            return _serde::__private::Err(
1544                                <__A::Error as _serde::de::Error>::missing_field(
1545                                    "minAnkleHeightMS",
1546                                ),
1547                            );
1548                            #[cfg(not(feature = "strict"))] Default::default()
1549                        }
1550                    };
1551                    let m_maxKneeAngleDegrees = match m_maxKneeAngleDegrees {
1552                        _serde::__private::Some(__field) => __field,
1553                        _serde::__private::None => {
1554                            #[cfg(feature = "strict")]
1555                            return _serde::__private::Err(
1556                                <__A::Error as _serde::de::Error>::missing_field(
1557                                    "maxKneeAngleDegrees",
1558                                ),
1559                            );
1560                            #[cfg(not(feature = "strict"))] Default::default()
1561                        }
1562                    };
1563                    let m_minKneeAngleDegrees = match m_minKneeAngleDegrees {
1564                        _serde::__private::Some(__field) => __field,
1565                        _serde::__private::None => {
1566                            #[cfg(feature = "strict")]
1567                            return _serde::__private::Err(
1568                                <__A::Error as _serde::de::Error>::missing_field(
1569                                    "minKneeAngleDegrees",
1570                                ),
1571                            );
1572                            #[cfg(not(feature = "strict"))] Default::default()
1573                        }
1574                    };
1575                    let m_verticalError = match m_verticalError {
1576                        _serde::__private::Some(__field) => __field,
1577                        _serde::__private::None => {
1578                            #[cfg(feature = "strict")]
1579                            return _serde::__private::Err(
1580                                <__A::Error as _serde::de::Error>::missing_field(
1581                                    "verticalError",
1582                                ),
1583                            );
1584                            #[cfg(not(feature = "strict"))] Default::default()
1585                        }
1586                    };
1587                    let m_maxAnkleAngleDegrees = match m_maxAnkleAngleDegrees {
1588                        _serde::__private::Some(__field) => __field,
1589                        _serde::__private::None => {
1590                            #[cfg(feature = "strict")]
1591                            return _serde::__private::Err(
1592                                <__A::Error as _serde::de::Error>::missing_field(
1593                                    "maxAnkleAngleDegrees",
1594                                ),
1595                            );
1596                            #[cfg(not(feature = "strict"))] Default::default()
1597                        }
1598                    };
1599                    let m_hipIndex = match m_hipIndex {
1600                        _serde::__private::Some(__field) => __field,
1601                        _serde::__private::None => {
1602                            #[cfg(feature = "strict")]
1603                            return _serde::__private::Err(
1604                                <__A::Error as _serde::de::Error>::missing_field("hipIndex"),
1605                            );
1606                            #[cfg(not(feature = "strict"))] Default::default()
1607                        }
1608                    };
1609                    let m_kneeIndex = match m_kneeIndex {
1610                        _serde::__private::Some(__field) => __field,
1611                        _serde::__private::None => {
1612                            #[cfg(feature = "strict")]
1613                            return _serde::__private::Err(
1614                                <__A::Error as _serde::de::Error>::missing_field(
1615                                    "kneeIndex",
1616                                ),
1617                            );
1618                            #[cfg(not(feature = "strict"))] Default::default()
1619                        }
1620                    };
1621                    let m_ankleIndex = match m_ankleIndex {
1622                        _serde::__private::Some(__field) => __field,
1623                        _serde::__private::None => {
1624                            #[cfg(feature = "strict")]
1625                            return _serde::__private::Err(
1626                                <__A::Error as _serde::de::Error>::missing_field(
1627                                    "ankleIndex",
1628                                ),
1629                            );
1630                            #[cfg(not(feature = "strict"))] Default::default()
1631                        }
1632                    };
1633                    let m_hitSomething = match m_hitSomething {
1634                        _serde::__private::Some(__field) => __field,
1635                        _serde::__private::None => {
1636                            #[cfg(feature = "strict")]
1637                            return _serde::__private::Err(
1638                                <__A::Error as _serde::de::Error>::missing_field(
1639                                    "hitSomething",
1640                                ),
1641                            );
1642                            #[cfg(not(feature = "strict"))] Default::default()
1643                        }
1644                    };
1645                    let m_isPlantedMS = match m_isPlantedMS {
1646                        _serde::__private::Some(__field) => __field,
1647                        _serde::__private::None => {
1648                            #[cfg(feature = "strict")]
1649                            return _serde::__private::Err(
1650                                <__A::Error as _serde::de::Error>::missing_field(
1651                                    "isPlantedMS",
1652                                ),
1653                            );
1654                            #[cfg(not(feature = "strict"))] Default::default()
1655                        }
1656                    };
1657                    let m_isOriginalAnkleTransformMSSet = match m_isOriginalAnkleTransformMSSet {
1658                        _serde::__private::Some(__field) => __field,
1659                        _serde::__private::None => {
1660                            #[cfg(feature = "strict")]
1661                            return _serde::__private::Err(
1662                                <__A::Error as _serde::de::Error>::missing_field(
1663                                    "isOriginalAnkleTransformMSSet",
1664                                ),
1665                            );
1666                            #[cfg(not(feature = "strict"))] Default::default()
1667                        }
1668                    };
1669                    let __ptr = __A::class_ptr(&mut __map);
1670                    _serde::__private::Ok(hkbFootIkModifierLeg {
1671                        __ptr,
1672                        m_originalAnkleTransformMS,
1673                        m_kneeAxisLS,
1674                        m_footEndLS,
1675                        m_ungroundedEvent,
1676                        m_footPlantedAnkleHeightMS,
1677                        m_footRaisedAnkleHeightMS,
1678                        m_maxAnkleHeightMS,
1679                        m_minAnkleHeightMS,
1680                        m_maxKneeAngleDegrees,
1681                        m_minKneeAngleDegrees,
1682                        m_verticalError,
1683                        m_maxAnkleAngleDegrees,
1684                        m_hipIndex,
1685                        m_kneeIndex,
1686                        m_ankleIndex,
1687                        m_hitSomething,
1688                        m_isPlantedMS,
1689                        m_isOriginalAnkleTransformMSSet,
1690                        ..Default::default()
1691                    })
1692                }
1693            }
1694            const FIELDS: &[&str] = &[
1695                "originalAnkleTransformMS",
1696                "prevAnkleRotLS",
1697                "kneeAxisLS",
1698                "footEndLS",
1699                "ungroundedEvent",
1700                "footPlantedAnkleHeightMS",
1701                "footRaisedAnkleHeightMS",
1702                "maxAnkleHeightMS",
1703                "minAnkleHeightMS",
1704                "maxKneeAngleDegrees",
1705                "minKneeAngleDegrees",
1706                "verticalError",
1707                "maxAnkleAngleDegrees",
1708                "hipIndex",
1709                "kneeIndex",
1710                "ankleIndex",
1711                "hitSomething",
1712                "isPlantedMS",
1713                "isOriginalAnkleTransformMSSet",
1714            ];
1715            _serde::Deserializer::deserialize_struct(
1716                deserializer,
1717                "hkbFootIkModifierLeg",
1718                FIELDS,
1719                __hkbFootIkModifierLegVisitor {
1720                    marker: _serde::__private::PhantomData::<hkbFootIkModifierLeg>,
1721                    lifetime: _serde::__private::PhantomData,
1722                },
1723            )
1724        }
1725    }
1726};