havok_classes/generated/
hkbFootIkDriverInfoLeg_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbFootIkDriverInfoLeg`
5/// - version: `0`
6/// - signature: `0x224b18d1`
7/// - size: ` 96`(x86)/` 96`(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 hkbFootIkDriverInfoLeg {
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: `prevAnkleRotLS`(ctype: `hkQuaternion`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 16`(x86)/` 16`(x86_64)
30    /// - flags: `SERIALIZE_IGNORED`
31    #[cfg_attr(feature = "json_schema", schemars(rename = "prevAnkleRotLS"))]
32    #[cfg_attr(feature = "serde", serde(rename = "prevAnkleRotLS"))]
33    pub m_prevAnkleRotLS: Quaternion,
34    /// # C++ Info
35    /// - name: `kneeAxisLS`(ctype: `hkVector4`)
36    /// - offset: ` 16`(x86)/` 16`(x86_64)
37    /// - type_size: ` 16`(x86)/` 16`(x86_64)
38    #[cfg_attr(feature = "json_schema", schemars(rename = "kneeAxisLS"))]
39    #[cfg_attr(feature = "serde", serde(rename = "kneeAxisLS"))]
40    pub m_kneeAxisLS: Vector4,
41    /// # C++ Info
42    /// - name: `footEndLS`(ctype: `hkVector4`)
43    /// - offset: ` 32`(x86)/` 32`(x86_64)
44    /// - type_size: ` 16`(x86)/` 16`(x86_64)
45    #[cfg_attr(feature = "json_schema", schemars(rename = "footEndLS"))]
46    #[cfg_attr(feature = "serde", serde(rename = "footEndLS"))]
47    pub m_footEndLS: Vector4,
48    /// # C++ Info
49    /// - name: `footPlantedAnkleHeightMS`(ctype: `hkReal`)
50    /// - offset: ` 48`(x86)/` 48`(x86_64)
51    /// - type_size: `  4`(x86)/`  4`(x86_64)
52    #[cfg_attr(feature = "json_schema", schemars(rename = "footPlantedAnkleHeightMS"))]
53    #[cfg_attr(feature = "serde", serde(rename = "footPlantedAnkleHeightMS"))]
54    pub m_footPlantedAnkleHeightMS: f32,
55    /// # C++ Info
56    /// - name: `footRaisedAnkleHeightMS`(ctype: `hkReal`)
57    /// - offset: ` 52`(x86)/` 52`(x86_64)
58    /// - type_size: `  4`(x86)/`  4`(x86_64)
59    #[cfg_attr(feature = "json_schema", schemars(rename = "footRaisedAnkleHeightMS"))]
60    #[cfg_attr(feature = "serde", serde(rename = "footRaisedAnkleHeightMS"))]
61    pub m_footRaisedAnkleHeightMS: f32,
62    /// # C++ Info
63    /// - name: `maxAnkleHeightMS`(ctype: `hkReal`)
64    /// - offset: ` 56`(x86)/` 56`(x86_64)
65    /// - type_size: `  4`(x86)/`  4`(x86_64)
66    #[cfg_attr(feature = "json_schema", schemars(rename = "maxAnkleHeightMS"))]
67    #[cfg_attr(feature = "serde", serde(rename = "maxAnkleHeightMS"))]
68    pub m_maxAnkleHeightMS: f32,
69    /// # C++ Info
70    /// - name: `minAnkleHeightMS`(ctype: `hkReal`)
71    /// - offset: ` 60`(x86)/` 60`(x86_64)
72    /// - type_size: `  4`(x86)/`  4`(x86_64)
73    #[cfg_attr(feature = "json_schema", schemars(rename = "minAnkleHeightMS"))]
74    #[cfg_attr(feature = "serde", serde(rename = "minAnkleHeightMS"))]
75    pub m_minAnkleHeightMS: f32,
76    /// # C++ Info
77    /// - name: `maxKneeAngleDegrees`(ctype: `hkReal`)
78    /// - offset: ` 64`(x86)/` 64`(x86_64)
79    /// - type_size: `  4`(x86)/`  4`(x86_64)
80    #[cfg_attr(feature = "json_schema", schemars(rename = "maxKneeAngleDegrees"))]
81    #[cfg_attr(feature = "serde", serde(rename = "maxKneeAngleDegrees"))]
82    pub m_maxKneeAngleDegrees: f32,
83    /// # C++ Info
84    /// - name: `minKneeAngleDegrees`(ctype: `hkReal`)
85    /// - offset: ` 68`(x86)/` 68`(x86_64)
86    /// - type_size: `  4`(x86)/`  4`(x86_64)
87    #[cfg_attr(feature = "json_schema", schemars(rename = "minKneeAngleDegrees"))]
88    #[cfg_attr(feature = "serde", serde(rename = "minKneeAngleDegrees"))]
89    pub m_minKneeAngleDegrees: f32,
90    /// # C++ Info
91    /// - name: `maxAnkleAngleDegrees`(ctype: `hkReal`)
92    /// - offset: ` 72`(x86)/` 72`(x86_64)
93    /// - type_size: `  4`(x86)/`  4`(x86_64)
94    #[cfg_attr(feature = "json_schema", schemars(rename = "maxAnkleAngleDegrees"))]
95    #[cfg_attr(feature = "serde", serde(rename = "maxAnkleAngleDegrees"))]
96    pub m_maxAnkleAngleDegrees: f32,
97    /// # C++ Info
98    /// - name: `hipIndex`(ctype: `hkInt16`)
99    /// - offset: ` 76`(x86)/` 76`(x86_64)
100    /// - type_size: `  2`(x86)/`  2`(x86_64)
101    #[cfg_attr(feature = "json_schema", schemars(rename = "hipIndex"))]
102    #[cfg_attr(feature = "serde", serde(rename = "hipIndex"))]
103    pub m_hipIndex: i16,
104    /// # C++ Info
105    /// - name: `kneeIndex`(ctype: `hkInt16`)
106    /// - offset: ` 78`(x86)/` 78`(x86_64)
107    /// - type_size: `  2`(x86)/`  2`(x86_64)
108    #[cfg_attr(feature = "json_schema", schemars(rename = "kneeIndex"))]
109    #[cfg_attr(feature = "serde", serde(rename = "kneeIndex"))]
110    pub m_kneeIndex: i16,
111    /// # C++ Info
112    /// - name: `ankleIndex`(ctype: `hkInt16`)
113    /// - offset: ` 80`(x86)/` 80`(x86_64)
114    /// - type_size: `  2`(x86)/`  2`(x86_64)
115    #[cfg_attr(feature = "json_schema", schemars(rename = "ankleIndex"))]
116    #[cfg_attr(feature = "serde", serde(rename = "ankleIndex"))]
117    pub m_ankleIndex: i16,
118}
119const _: () = {
120    use havok_serde as _serde;
121    impl _serde::HavokClass for hkbFootIkDriverInfoLeg {
122        #[inline]
123        fn name(&self) -> &'static str {
124            "hkbFootIkDriverInfoLeg"
125        }
126        #[inline]
127        fn signature(&self) -> _serde::__private::Signature {
128            _serde::__private::Signature::new(0x224b18d1)
129        }
130        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
131        fn deps_indexes(&self) -> Vec<usize> {
132            let mut v = Vec::new();
133            v
134        }
135    }
136    impl _serde::Serialize for hkbFootIkDriverInfoLeg {
137        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
138        where
139            S: _serde::ser::Serializer,
140        {
141            let class_meta = self
142                .__ptr
143                .map(|name| (name, _serde::__private::Signature::new(0x224b18d1)));
144            let mut serializer = __serializer
145                .serialize_struct("hkbFootIkDriverInfoLeg", class_meta, (96u64, 96u64))?;
146            serializer.skip_field("prevAnkleRotLS", &self.m_prevAnkleRotLS)?;
147            serializer.serialize_field("kneeAxisLS", &self.m_kneeAxisLS)?;
148            serializer.serialize_field("footEndLS", &self.m_footEndLS)?;
149            serializer
150                .serialize_field(
151                    "footPlantedAnkleHeightMS",
152                    &self.m_footPlantedAnkleHeightMS,
153                )?;
154            serializer
155                .serialize_field(
156                    "footRaisedAnkleHeightMS",
157                    &self.m_footRaisedAnkleHeightMS,
158                )?;
159            serializer.serialize_field("maxAnkleHeightMS", &self.m_maxAnkleHeightMS)?;
160            serializer.serialize_field("minAnkleHeightMS", &self.m_minAnkleHeightMS)?;
161            serializer
162                .serialize_field("maxKneeAngleDegrees", &self.m_maxKneeAngleDegrees)?;
163            serializer
164                .serialize_field("minKneeAngleDegrees", &self.m_minKneeAngleDegrees)?;
165            serializer
166                .serialize_field("maxAnkleAngleDegrees", &self.m_maxAnkleAngleDegrees)?;
167            serializer.serialize_field("hipIndex", &self.m_hipIndex)?;
168            serializer.serialize_field("kneeIndex", &self.m_kneeIndex)?;
169            serializer.serialize_field("ankleIndex", &self.m_ankleIndex)?;
170            serializer.pad_field([0u8; 14usize].as_slice(), [0u8; 14usize].as_slice())?;
171            serializer.end()
172        }
173    }
174};
175#[doc(hidden)]
176#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
177const _: () = {
178    use havok_serde as _serde;
179    #[automatically_derived]
180    impl<'de> _serde::Deserialize<'de> for hkbFootIkDriverInfoLeg {
181        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
182        where
183            __D: _serde::Deserializer<'de>,
184        {
185            #[allow(non_camel_case_types)]
186            enum __Field {
187                m_kneeAxisLS,
188                m_footEndLS,
189                m_footPlantedAnkleHeightMS,
190                m_footRaisedAnkleHeightMS,
191                m_maxAnkleHeightMS,
192                m_minAnkleHeightMS,
193                m_maxKneeAngleDegrees,
194                m_minKneeAngleDegrees,
195                m_maxAnkleAngleDegrees,
196                m_hipIndex,
197                m_kneeIndex,
198                m_ankleIndex,
199                __ignore,
200            }
201            struct __FieldVisitor;
202            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
203                type Value = __Field;
204                fn expecting(
205                    &self,
206                    __formatter: &mut core::fmt::Formatter,
207                ) -> core::fmt::Result {
208                    core::fmt::Formatter::write_str(__formatter, "field identifier")
209                }
210                /// Intended for use in XML.
211                #[allow(clippy::match_single_binding)]
212                #[allow(clippy::reversed_empty_ranges)]
213                #[allow(clippy::single_match)]
214                fn visit_key<__E>(
215                    self,
216                    __value: &str,
217                ) -> core::result::Result<Self::Value, __E>
218                where
219                    __E: _serde::de::Error,
220                {
221                    match __value {
222                        "kneeAxisLS" => Ok(__Field::m_kneeAxisLS),
223                        "footEndLS" => Ok(__Field::m_footEndLS),
224                        "footPlantedAnkleHeightMS" => {
225                            Ok(__Field::m_footPlantedAnkleHeightMS)
226                        }
227                        "footRaisedAnkleHeightMS" => {
228                            Ok(__Field::m_footRaisedAnkleHeightMS)
229                        }
230                        "maxAnkleHeightMS" => Ok(__Field::m_maxAnkleHeightMS),
231                        "minAnkleHeightMS" => Ok(__Field::m_minAnkleHeightMS),
232                        "maxKneeAngleDegrees" => Ok(__Field::m_maxKneeAngleDegrees),
233                        "minKneeAngleDegrees" => Ok(__Field::m_minKneeAngleDegrees),
234                        "maxAnkleAngleDegrees" => Ok(__Field::m_maxAnkleAngleDegrees),
235                        "hipIndex" => Ok(__Field::m_hipIndex),
236                        "kneeIndex" => Ok(__Field::m_kneeIndex),
237                        "ankleIndex" => Ok(__Field::m_ankleIndex),
238                        _ => Ok(__Field::__ignore),
239                    }
240                }
241            }
242            impl<'de> _serde::Deserialize<'de> for __Field {
243                #[inline]
244                fn deserialize<__D>(
245                    __deserializer: __D,
246                ) -> core::result::Result<Self, __D::Error>
247                where
248                    __D: _serde::Deserializer<'de>,
249                {
250                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
251                }
252            }
253            struct __hkbFootIkDriverInfoLegVisitor<'de> {
254                marker: _serde::__private::PhantomData<hkbFootIkDriverInfoLeg>,
255                lifetime: _serde::__private::PhantomData<&'de ()>,
256            }
257            #[allow(clippy::match_single_binding)]
258            #[allow(clippy::reversed_empty_ranges)]
259            #[allow(clippy::single_match)]
260            impl<'de> _serde::de::Visitor<'de> for __hkbFootIkDriverInfoLegVisitor<'de> {
261                type Value = hkbFootIkDriverInfoLeg;
262                fn expecting(
263                    &self,
264                    __formatter: &mut core::fmt::Formatter,
265                ) -> core::fmt::Result {
266                    core::fmt::Formatter::write_str(
267                        __formatter,
268                        "struct hkbFootIkDriverInfoLeg",
269                    )
270                }
271                fn visit_struct_for_bytes<__A>(
272                    self,
273                    mut __map: __A,
274                ) -> _serde::__private::Result<Self::Value, __A::Error>
275                where
276                    __A: _serde::de::MapAccess<'de>,
277                {
278                    let __ptr = __A::class_ptr(&mut __map);
279                    let mut m_prevAnkleRotLS: _serde::__private::Option<Quaternion> = _serde::__private::None;
280                    let mut m_kneeAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
281                    let mut m_footEndLS: _serde::__private::Option<Vector4> = _serde::__private::None;
282                    let mut m_footPlantedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
283                    let mut m_footRaisedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
284                    let mut m_maxAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
285                    let mut m_minAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
286                    let mut m_maxKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
287                    let mut m_minKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
288                    let mut m_maxAnkleAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
289                    let mut m_hipIndex: _serde::__private::Option<i16> = _serde::__private::None;
290                    let mut m_kneeIndex: _serde::__private::Option<i16> = _serde::__private::None;
291                    let mut m_ankleIndex: _serde::__private::Option<i16> = _serde::__private::None;
292                    for i in 0..13usize {
293                        match i {
294                            0usize => {
295                                if _serde::__private::Option::is_some(&m_prevAnkleRotLS) {
296                                    return _serde::__private::Err(
297                                        <__A::Error as _serde::de::Error>::duplicate_field(
298                                            "prevAnkleRotLS",
299                                        ),
300                                    );
301                                }
302                                m_prevAnkleRotLS = _serde::__private::Some(
303                                    match __A::next_value::<Quaternion>(&mut __map) {
304                                        _serde::__private::Ok(__val) => __val,
305                                        _serde::__private::Err(__err) => {
306                                            return _serde::__private::Err(__err);
307                                        }
308                                    },
309                                );
310                            }
311                            1usize => {
312                                if _serde::__private::Option::is_some(&m_kneeAxisLS) {
313                                    return _serde::__private::Err(
314                                        <__A::Error as _serde::de::Error>::duplicate_field(
315                                            "kneeAxisLS",
316                                        ),
317                                    );
318                                }
319                                m_kneeAxisLS = _serde::__private::Some(
320                                    match __A::next_value::<Vector4>(&mut __map) {
321                                        _serde::__private::Ok(__val) => __val,
322                                        _serde::__private::Err(__err) => {
323                                            return _serde::__private::Err(__err);
324                                        }
325                                    },
326                                );
327                            }
328                            2usize => {
329                                if _serde::__private::Option::is_some(&m_footEndLS) {
330                                    return _serde::__private::Err(
331                                        <__A::Error as _serde::de::Error>::duplicate_field(
332                                            "footEndLS",
333                                        ),
334                                    );
335                                }
336                                m_footEndLS = _serde::__private::Some(
337                                    match __A::next_value::<Vector4>(&mut __map) {
338                                        _serde::__private::Ok(__val) => __val,
339                                        _serde::__private::Err(__err) => {
340                                            return _serde::__private::Err(__err);
341                                        }
342                                    },
343                                );
344                            }
345                            3usize => {
346                                if _serde::__private::Option::is_some(
347                                    &m_footPlantedAnkleHeightMS,
348                                ) {
349                                    return _serde::__private::Err(
350                                        <__A::Error as _serde::de::Error>::duplicate_field(
351                                            "footPlantedAnkleHeightMS",
352                                        ),
353                                    );
354                                }
355                                m_footPlantedAnkleHeightMS = _serde::__private::Some(
356                                    match __A::next_value::<f32>(&mut __map) {
357                                        _serde::__private::Ok(__val) => __val,
358                                        _serde::__private::Err(__err) => {
359                                            return _serde::__private::Err(__err);
360                                        }
361                                    },
362                                );
363                            }
364                            4usize => {
365                                if _serde::__private::Option::is_some(
366                                    &m_footRaisedAnkleHeightMS,
367                                ) {
368                                    return _serde::__private::Err(
369                                        <__A::Error as _serde::de::Error>::duplicate_field(
370                                            "footRaisedAnkleHeightMS",
371                                        ),
372                                    );
373                                }
374                                m_footRaisedAnkleHeightMS = _serde::__private::Some(
375                                    match __A::next_value::<f32>(&mut __map) {
376                                        _serde::__private::Ok(__val) => __val,
377                                        _serde::__private::Err(__err) => {
378                                            return _serde::__private::Err(__err);
379                                        }
380                                    },
381                                );
382                            }
383                            5usize => {
384                                if _serde::__private::Option::is_some(&m_maxAnkleHeightMS) {
385                                    return _serde::__private::Err(
386                                        <__A::Error as _serde::de::Error>::duplicate_field(
387                                            "maxAnkleHeightMS",
388                                        ),
389                                    );
390                                }
391                                m_maxAnkleHeightMS = _serde::__private::Some(
392                                    match __A::next_value::<f32>(&mut __map) {
393                                        _serde::__private::Ok(__val) => __val,
394                                        _serde::__private::Err(__err) => {
395                                            return _serde::__private::Err(__err);
396                                        }
397                                    },
398                                );
399                            }
400                            6usize => {
401                                if _serde::__private::Option::is_some(&m_minAnkleHeightMS) {
402                                    return _serde::__private::Err(
403                                        <__A::Error as _serde::de::Error>::duplicate_field(
404                                            "minAnkleHeightMS",
405                                        ),
406                                    );
407                                }
408                                m_minAnkleHeightMS = _serde::__private::Some(
409                                    match __A::next_value::<f32>(&mut __map) {
410                                        _serde::__private::Ok(__val) => __val,
411                                        _serde::__private::Err(__err) => {
412                                            return _serde::__private::Err(__err);
413                                        }
414                                    },
415                                );
416                            }
417                            7usize => {
418                                if _serde::__private::Option::is_some(
419                                    &m_maxKneeAngleDegrees,
420                                ) {
421                                    return _serde::__private::Err(
422                                        <__A::Error as _serde::de::Error>::duplicate_field(
423                                            "maxKneeAngleDegrees",
424                                        ),
425                                    );
426                                }
427                                m_maxKneeAngleDegrees = _serde::__private::Some(
428                                    match __A::next_value::<f32>(&mut __map) {
429                                        _serde::__private::Ok(__val) => __val,
430                                        _serde::__private::Err(__err) => {
431                                            return _serde::__private::Err(__err);
432                                        }
433                                    },
434                                );
435                            }
436                            8usize => {
437                                if _serde::__private::Option::is_some(
438                                    &m_minKneeAngleDegrees,
439                                ) {
440                                    return _serde::__private::Err(
441                                        <__A::Error as _serde::de::Error>::duplicate_field(
442                                            "minKneeAngleDegrees",
443                                        ),
444                                    );
445                                }
446                                m_minKneeAngleDegrees = _serde::__private::Some(
447                                    match __A::next_value::<f32>(&mut __map) {
448                                        _serde::__private::Ok(__val) => __val,
449                                        _serde::__private::Err(__err) => {
450                                            return _serde::__private::Err(__err);
451                                        }
452                                    },
453                                );
454                            }
455                            9usize => {
456                                if _serde::__private::Option::is_some(
457                                    &m_maxAnkleAngleDegrees,
458                                ) {
459                                    return _serde::__private::Err(
460                                        <__A::Error as _serde::de::Error>::duplicate_field(
461                                            "maxAnkleAngleDegrees",
462                                        ),
463                                    );
464                                }
465                                m_maxAnkleAngleDegrees = _serde::__private::Some(
466                                    match __A::next_value::<f32>(&mut __map) {
467                                        _serde::__private::Ok(__val) => __val,
468                                        _serde::__private::Err(__err) => {
469                                            return _serde::__private::Err(__err);
470                                        }
471                                    },
472                                );
473                            }
474                            10usize => {
475                                if _serde::__private::Option::is_some(&m_hipIndex) {
476                                    return _serde::__private::Err(
477                                        <__A::Error as _serde::de::Error>::duplicate_field(
478                                            "hipIndex",
479                                        ),
480                                    );
481                                }
482                                m_hipIndex = _serde::__private::Some(
483                                    match __A::next_value::<i16>(&mut __map) {
484                                        _serde::__private::Ok(__val) => __val,
485                                        _serde::__private::Err(__err) => {
486                                            return _serde::__private::Err(__err);
487                                        }
488                                    },
489                                );
490                            }
491                            11usize => {
492                                if _serde::__private::Option::is_some(&m_kneeIndex) {
493                                    return _serde::__private::Err(
494                                        <__A::Error as _serde::de::Error>::duplicate_field(
495                                            "kneeIndex",
496                                        ),
497                                    );
498                                }
499                                m_kneeIndex = _serde::__private::Some(
500                                    match __A::next_value::<i16>(&mut __map) {
501                                        _serde::__private::Ok(__val) => __val,
502                                        _serde::__private::Err(__err) => {
503                                            return _serde::__private::Err(__err);
504                                        }
505                                    },
506                                );
507                            }
508                            12usize => {
509                                if _serde::__private::Option::is_some(&m_ankleIndex) {
510                                    return _serde::__private::Err(
511                                        <__A::Error as _serde::de::Error>::duplicate_field(
512                                            "ankleIndex",
513                                        ),
514                                    );
515                                }
516                                m_ankleIndex = _serde::__private::Some(
517                                    match __A::next_value::<i16>(&mut __map) {
518                                        _serde::__private::Ok(__val) => __val,
519                                        _serde::__private::Err(__err) => {
520                                            return _serde::__private::Err(__err);
521                                        }
522                                    },
523                                );
524                            }
525                            _ => {}
526                        }
527                    }
528                    __A::pad(&mut __map, 14usize, 14usize)?;
529                    let m_prevAnkleRotLS = match m_prevAnkleRotLS {
530                        _serde::__private::Some(__field) => __field,
531                        _serde::__private::None => {
532                            return _serde::__private::Err(
533                                <__A::Error as _serde::de::Error>::missing_field(
534                                    "prevAnkleRotLS",
535                                ),
536                            );
537                        }
538                    };
539                    let m_kneeAxisLS = match m_kneeAxisLS {
540                        _serde::__private::Some(__field) => __field,
541                        _serde::__private::None => {
542                            return _serde::__private::Err(
543                                <__A::Error as _serde::de::Error>::missing_field(
544                                    "kneeAxisLS",
545                                ),
546                            );
547                        }
548                    };
549                    let m_footEndLS = match m_footEndLS {
550                        _serde::__private::Some(__field) => __field,
551                        _serde::__private::None => {
552                            return _serde::__private::Err(
553                                <__A::Error as _serde::de::Error>::missing_field(
554                                    "footEndLS",
555                                ),
556                            );
557                        }
558                    };
559                    let m_footPlantedAnkleHeightMS = match m_footPlantedAnkleHeightMS {
560                        _serde::__private::Some(__field) => __field,
561                        _serde::__private::None => {
562                            return _serde::__private::Err(
563                                <__A::Error as _serde::de::Error>::missing_field(
564                                    "footPlantedAnkleHeightMS",
565                                ),
566                            );
567                        }
568                    };
569                    let m_footRaisedAnkleHeightMS = match m_footRaisedAnkleHeightMS {
570                        _serde::__private::Some(__field) => __field,
571                        _serde::__private::None => {
572                            return _serde::__private::Err(
573                                <__A::Error as _serde::de::Error>::missing_field(
574                                    "footRaisedAnkleHeightMS",
575                                ),
576                            );
577                        }
578                    };
579                    let m_maxAnkleHeightMS = match m_maxAnkleHeightMS {
580                        _serde::__private::Some(__field) => __field,
581                        _serde::__private::None => {
582                            return _serde::__private::Err(
583                                <__A::Error as _serde::de::Error>::missing_field(
584                                    "maxAnkleHeightMS",
585                                ),
586                            );
587                        }
588                    };
589                    let m_minAnkleHeightMS = match m_minAnkleHeightMS {
590                        _serde::__private::Some(__field) => __field,
591                        _serde::__private::None => {
592                            return _serde::__private::Err(
593                                <__A::Error as _serde::de::Error>::missing_field(
594                                    "minAnkleHeightMS",
595                                ),
596                            );
597                        }
598                    };
599                    let m_maxKneeAngleDegrees = match m_maxKneeAngleDegrees {
600                        _serde::__private::Some(__field) => __field,
601                        _serde::__private::None => {
602                            return _serde::__private::Err(
603                                <__A::Error as _serde::de::Error>::missing_field(
604                                    "maxKneeAngleDegrees",
605                                ),
606                            );
607                        }
608                    };
609                    let m_minKneeAngleDegrees = match m_minKneeAngleDegrees {
610                        _serde::__private::Some(__field) => __field,
611                        _serde::__private::None => {
612                            return _serde::__private::Err(
613                                <__A::Error as _serde::de::Error>::missing_field(
614                                    "minKneeAngleDegrees",
615                                ),
616                            );
617                        }
618                    };
619                    let m_maxAnkleAngleDegrees = match m_maxAnkleAngleDegrees {
620                        _serde::__private::Some(__field) => __field,
621                        _serde::__private::None => {
622                            return _serde::__private::Err(
623                                <__A::Error as _serde::de::Error>::missing_field(
624                                    "maxAnkleAngleDegrees",
625                                ),
626                            );
627                        }
628                    };
629                    let m_hipIndex = match m_hipIndex {
630                        _serde::__private::Some(__field) => __field,
631                        _serde::__private::None => {
632                            return _serde::__private::Err(
633                                <__A::Error as _serde::de::Error>::missing_field("hipIndex"),
634                            );
635                        }
636                    };
637                    let m_kneeIndex = match m_kneeIndex {
638                        _serde::__private::Some(__field) => __field,
639                        _serde::__private::None => {
640                            return _serde::__private::Err(
641                                <__A::Error as _serde::de::Error>::missing_field(
642                                    "kneeIndex",
643                                ),
644                            );
645                        }
646                    };
647                    let m_ankleIndex = match m_ankleIndex {
648                        _serde::__private::Some(__field) => __field,
649                        _serde::__private::None => {
650                            return _serde::__private::Err(
651                                <__A::Error as _serde::de::Error>::missing_field(
652                                    "ankleIndex",
653                                ),
654                            );
655                        }
656                    };
657                    _serde::__private::Ok(hkbFootIkDriverInfoLeg {
658                        __ptr,
659                        m_prevAnkleRotLS,
660                        m_kneeAxisLS,
661                        m_footEndLS,
662                        m_footPlantedAnkleHeightMS,
663                        m_footRaisedAnkleHeightMS,
664                        m_maxAnkleHeightMS,
665                        m_minAnkleHeightMS,
666                        m_maxKneeAngleDegrees,
667                        m_minKneeAngleDegrees,
668                        m_maxAnkleAngleDegrees,
669                        m_hipIndex,
670                        m_kneeIndex,
671                        m_ankleIndex,
672                    })
673                }
674                #[allow(clippy::manual_unwrap_or_default)]
675                fn visit_struct<__A>(
676                    self,
677                    mut __map: __A,
678                ) -> _serde::__private::Result<Self::Value, __A::Error>
679                where
680                    __A: _serde::de::MapAccess<'de>,
681                {
682                    let mut m_kneeAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
683                    let mut m_footEndLS: _serde::__private::Option<Vector4> = _serde::__private::None;
684                    let mut m_footPlantedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
685                    let mut m_footRaisedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
686                    let mut m_maxAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
687                    let mut m_minAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
688                    let mut m_maxKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
689                    let mut m_minKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
690                    let mut m_maxAnkleAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
691                    let mut m_hipIndex: _serde::__private::Option<i16> = _serde::__private::None;
692                    let mut m_kneeIndex: _serde::__private::Option<i16> = _serde::__private::None;
693                    let mut m_ankleIndex: _serde::__private::Option<i16> = _serde::__private::None;
694                    while let _serde::__private::Some(__key) = {
695                        __A::next_key::<__Field>(&mut __map)?
696                    } {
697                        match __key {
698                            __Field::m_kneeAxisLS => {
699                                #[cfg(
700                                    any(feature = "strict", feature = "ignore_duplicates")
701                                )]
702                                if _serde::__private::Option::is_some(&m_kneeAxisLS) {
703                                    #[cfg(feature = "ignore_duplicates")]
704                                    {
705                                        __A::skip_value(&mut __map)?;
706                                        continue;
707                                    }
708                                    #[cfg(feature = "strict")]
709                                    return _serde::__private::Err(
710                                        <__A::Error as _serde::de::Error>::duplicate_field(
711                                            "kneeAxisLS",
712                                        ),
713                                    );
714                                }
715                                m_kneeAxisLS = _serde::__private::Some(
716                                    match __A::next_value::<Vector4>(&mut __map) {
717                                        _serde::__private::Ok(__val) => __val,
718                                        _serde::__private::Err(__err) => {
719                                            return _serde::__private::Err(__err);
720                                        }
721                                    },
722                                );
723                            }
724                            __Field::m_footEndLS => {
725                                #[cfg(
726                                    any(feature = "strict", feature = "ignore_duplicates")
727                                )]
728                                if _serde::__private::Option::is_some(&m_footEndLS) {
729                                    #[cfg(feature = "ignore_duplicates")]
730                                    {
731                                        __A::skip_value(&mut __map)?;
732                                        continue;
733                                    }
734                                    #[cfg(feature = "strict")]
735                                    return _serde::__private::Err(
736                                        <__A::Error as _serde::de::Error>::duplicate_field(
737                                            "footEndLS",
738                                        ),
739                                    );
740                                }
741                                m_footEndLS = _serde::__private::Some(
742                                    match __A::next_value::<Vector4>(&mut __map) {
743                                        _serde::__private::Ok(__val) => __val,
744                                        _serde::__private::Err(__err) => {
745                                            return _serde::__private::Err(__err);
746                                        }
747                                    },
748                                );
749                            }
750                            __Field::m_footPlantedAnkleHeightMS => {
751                                #[cfg(
752                                    any(feature = "strict", feature = "ignore_duplicates")
753                                )]
754                                if _serde::__private::Option::is_some(
755                                    &m_footPlantedAnkleHeightMS,
756                                ) {
757                                    #[cfg(feature = "ignore_duplicates")]
758                                    {
759                                        __A::skip_value(&mut __map)?;
760                                        continue;
761                                    }
762                                    #[cfg(feature = "strict")]
763                                    return _serde::__private::Err(
764                                        <__A::Error as _serde::de::Error>::duplicate_field(
765                                            "footPlantedAnkleHeightMS",
766                                        ),
767                                    );
768                                }
769                                m_footPlantedAnkleHeightMS = _serde::__private::Some(
770                                    match __A::next_value::<f32>(&mut __map) {
771                                        _serde::__private::Ok(__val) => __val,
772                                        _serde::__private::Err(__err) => {
773                                            return _serde::__private::Err(__err);
774                                        }
775                                    },
776                                );
777                            }
778                            __Field::m_footRaisedAnkleHeightMS => {
779                                #[cfg(
780                                    any(feature = "strict", feature = "ignore_duplicates")
781                                )]
782                                if _serde::__private::Option::is_some(
783                                    &m_footRaisedAnkleHeightMS,
784                                ) {
785                                    #[cfg(feature = "ignore_duplicates")]
786                                    {
787                                        __A::skip_value(&mut __map)?;
788                                        continue;
789                                    }
790                                    #[cfg(feature = "strict")]
791                                    return _serde::__private::Err(
792                                        <__A::Error as _serde::de::Error>::duplicate_field(
793                                            "footRaisedAnkleHeightMS",
794                                        ),
795                                    );
796                                }
797                                m_footRaisedAnkleHeightMS = _serde::__private::Some(
798                                    match __A::next_value::<f32>(&mut __map) {
799                                        _serde::__private::Ok(__val) => __val,
800                                        _serde::__private::Err(__err) => {
801                                            return _serde::__private::Err(__err);
802                                        }
803                                    },
804                                );
805                            }
806                            __Field::m_maxAnkleHeightMS => {
807                                #[cfg(
808                                    any(feature = "strict", feature = "ignore_duplicates")
809                                )]
810                                if _serde::__private::Option::is_some(&m_maxAnkleHeightMS) {
811                                    #[cfg(feature = "ignore_duplicates")]
812                                    {
813                                        __A::skip_value(&mut __map)?;
814                                        continue;
815                                    }
816                                    #[cfg(feature = "strict")]
817                                    return _serde::__private::Err(
818                                        <__A::Error as _serde::de::Error>::duplicate_field(
819                                            "maxAnkleHeightMS",
820                                        ),
821                                    );
822                                }
823                                m_maxAnkleHeightMS = _serde::__private::Some(
824                                    match __A::next_value::<f32>(&mut __map) {
825                                        _serde::__private::Ok(__val) => __val,
826                                        _serde::__private::Err(__err) => {
827                                            return _serde::__private::Err(__err);
828                                        }
829                                    },
830                                );
831                            }
832                            __Field::m_minAnkleHeightMS => {
833                                #[cfg(
834                                    any(feature = "strict", feature = "ignore_duplicates")
835                                )]
836                                if _serde::__private::Option::is_some(&m_minAnkleHeightMS) {
837                                    #[cfg(feature = "ignore_duplicates")]
838                                    {
839                                        __A::skip_value(&mut __map)?;
840                                        continue;
841                                    }
842                                    #[cfg(feature = "strict")]
843                                    return _serde::__private::Err(
844                                        <__A::Error as _serde::de::Error>::duplicate_field(
845                                            "minAnkleHeightMS",
846                                        ),
847                                    );
848                                }
849                                m_minAnkleHeightMS = _serde::__private::Some(
850                                    match __A::next_value::<f32>(&mut __map) {
851                                        _serde::__private::Ok(__val) => __val,
852                                        _serde::__private::Err(__err) => {
853                                            return _serde::__private::Err(__err);
854                                        }
855                                    },
856                                );
857                            }
858                            __Field::m_maxKneeAngleDegrees => {
859                                #[cfg(
860                                    any(feature = "strict", feature = "ignore_duplicates")
861                                )]
862                                if _serde::__private::Option::is_some(
863                                    &m_maxKneeAngleDegrees,
864                                ) {
865                                    #[cfg(feature = "ignore_duplicates")]
866                                    {
867                                        __A::skip_value(&mut __map)?;
868                                        continue;
869                                    }
870                                    #[cfg(feature = "strict")]
871                                    return _serde::__private::Err(
872                                        <__A::Error as _serde::de::Error>::duplicate_field(
873                                            "maxKneeAngleDegrees",
874                                        ),
875                                    );
876                                }
877                                m_maxKneeAngleDegrees = _serde::__private::Some(
878                                    match __A::next_value::<f32>(&mut __map) {
879                                        _serde::__private::Ok(__val) => __val,
880                                        _serde::__private::Err(__err) => {
881                                            return _serde::__private::Err(__err);
882                                        }
883                                    },
884                                );
885                            }
886                            __Field::m_minKneeAngleDegrees => {
887                                #[cfg(
888                                    any(feature = "strict", feature = "ignore_duplicates")
889                                )]
890                                if _serde::__private::Option::is_some(
891                                    &m_minKneeAngleDegrees,
892                                ) {
893                                    #[cfg(feature = "ignore_duplicates")]
894                                    {
895                                        __A::skip_value(&mut __map)?;
896                                        continue;
897                                    }
898                                    #[cfg(feature = "strict")]
899                                    return _serde::__private::Err(
900                                        <__A::Error as _serde::de::Error>::duplicate_field(
901                                            "minKneeAngleDegrees",
902                                        ),
903                                    );
904                                }
905                                m_minKneeAngleDegrees = _serde::__private::Some(
906                                    match __A::next_value::<f32>(&mut __map) {
907                                        _serde::__private::Ok(__val) => __val,
908                                        _serde::__private::Err(__err) => {
909                                            return _serde::__private::Err(__err);
910                                        }
911                                    },
912                                );
913                            }
914                            __Field::m_maxAnkleAngleDegrees => {
915                                #[cfg(
916                                    any(feature = "strict", feature = "ignore_duplicates")
917                                )]
918                                if _serde::__private::Option::is_some(
919                                    &m_maxAnkleAngleDegrees,
920                                ) {
921                                    #[cfg(feature = "ignore_duplicates")]
922                                    {
923                                        __A::skip_value(&mut __map)?;
924                                        continue;
925                                    }
926                                    #[cfg(feature = "strict")]
927                                    return _serde::__private::Err(
928                                        <__A::Error as _serde::de::Error>::duplicate_field(
929                                            "maxAnkleAngleDegrees",
930                                        ),
931                                    );
932                                }
933                                m_maxAnkleAngleDegrees = _serde::__private::Some(
934                                    match __A::next_value::<f32>(&mut __map) {
935                                        _serde::__private::Ok(__val) => __val,
936                                        _serde::__private::Err(__err) => {
937                                            return _serde::__private::Err(__err);
938                                        }
939                                    },
940                                );
941                            }
942                            __Field::m_hipIndex => {
943                                #[cfg(
944                                    any(feature = "strict", feature = "ignore_duplicates")
945                                )]
946                                if _serde::__private::Option::is_some(&m_hipIndex) {
947                                    #[cfg(feature = "ignore_duplicates")]
948                                    {
949                                        __A::skip_value(&mut __map)?;
950                                        continue;
951                                    }
952                                    #[cfg(feature = "strict")]
953                                    return _serde::__private::Err(
954                                        <__A::Error as _serde::de::Error>::duplicate_field(
955                                            "hipIndex",
956                                        ),
957                                    );
958                                }
959                                m_hipIndex = _serde::__private::Some(
960                                    match __A::next_value::<i16>(&mut __map) {
961                                        _serde::__private::Ok(__val) => __val,
962                                        _serde::__private::Err(__err) => {
963                                            return _serde::__private::Err(__err);
964                                        }
965                                    },
966                                );
967                            }
968                            __Field::m_kneeIndex => {
969                                #[cfg(
970                                    any(feature = "strict", feature = "ignore_duplicates")
971                                )]
972                                if _serde::__private::Option::is_some(&m_kneeIndex) {
973                                    #[cfg(feature = "ignore_duplicates")]
974                                    {
975                                        __A::skip_value(&mut __map)?;
976                                        continue;
977                                    }
978                                    #[cfg(feature = "strict")]
979                                    return _serde::__private::Err(
980                                        <__A::Error as _serde::de::Error>::duplicate_field(
981                                            "kneeIndex",
982                                        ),
983                                    );
984                                }
985                                m_kneeIndex = _serde::__private::Some(
986                                    match __A::next_value::<i16>(&mut __map) {
987                                        _serde::__private::Ok(__val) => __val,
988                                        _serde::__private::Err(__err) => {
989                                            return _serde::__private::Err(__err);
990                                        }
991                                    },
992                                );
993                            }
994                            __Field::m_ankleIndex => {
995                                #[cfg(
996                                    any(feature = "strict", feature = "ignore_duplicates")
997                                )]
998                                if _serde::__private::Option::is_some(&m_ankleIndex) {
999                                    #[cfg(feature = "ignore_duplicates")]
1000                                    {
1001                                        __A::skip_value(&mut __map)?;
1002                                        continue;
1003                                    }
1004                                    #[cfg(feature = "strict")]
1005                                    return _serde::__private::Err(
1006                                        <__A::Error as _serde::de::Error>::duplicate_field(
1007                                            "ankleIndex",
1008                                        ),
1009                                    );
1010                                }
1011                                m_ankleIndex = _serde::__private::Some(
1012                                    match __A::next_value::<i16>(&mut __map) {
1013                                        _serde::__private::Ok(__val) => __val,
1014                                        _serde::__private::Err(__err) => {
1015                                            return _serde::__private::Err(__err);
1016                                        }
1017                                    },
1018                                );
1019                            }
1020                            _ => __A::skip_value(&mut __map)?,
1021                        }
1022                    }
1023                    let m_kneeAxisLS = match m_kneeAxisLS {
1024                        _serde::__private::Some(__field) => __field,
1025                        _serde::__private::None => {
1026                            #[cfg(feature = "strict")]
1027                            return _serde::__private::Err(
1028                                <__A::Error as _serde::de::Error>::missing_field(
1029                                    "kneeAxisLS",
1030                                ),
1031                            );
1032                            #[cfg(not(feature = "strict"))] Default::default()
1033                        }
1034                    };
1035                    let m_footEndLS = match m_footEndLS {
1036                        _serde::__private::Some(__field) => __field,
1037                        _serde::__private::None => {
1038                            #[cfg(feature = "strict")]
1039                            return _serde::__private::Err(
1040                                <__A::Error as _serde::de::Error>::missing_field(
1041                                    "footEndLS",
1042                                ),
1043                            );
1044                            #[cfg(not(feature = "strict"))] Default::default()
1045                        }
1046                    };
1047                    let m_footPlantedAnkleHeightMS = match m_footPlantedAnkleHeightMS {
1048                        _serde::__private::Some(__field) => __field,
1049                        _serde::__private::None => {
1050                            #[cfg(feature = "strict")]
1051                            return _serde::__private::Err(
1052                                <__A::Error as _serde::de::Error>::missing_field(
1053                                    "footPlantedAnkleHeightMS",
1054                                ),
1055                            );
1056                            #[cfg(not(feature = "strict"))] Default::default()
1057                        }
1058                    };
1059                    let m_footRaisedAnkleHeightMS = match m_footRaisedAnkleHeightMS {
1060                        _serde::__private::Some(__field) => __field,
1061                        _serde::__private::None => {
1062                            #[cfg(feature = "strict")]
1063                            return _serde::__private::Err(
1064                                <__A::Error as _serde::de::Error>::missing_field(
1065                                    "footRaisedAnkleHeightMS",
1066                                ),
1067                            );
1068                            #[cfg(not(feature = "strict"))] Default::default()
1069                        }
1070                    };
1071                    let m_maxAnkleHeightMS = match m_maxAnkleHeightMS {
1072                        _serde::__private::Some(__field) => __field,
1073                        _serde::__private::None => {
1074                            #[cfg(feature = "strict")]
1075                            return _serde::__private::Err(
1076                                <__A::Error as _serde::de::Error>::missing_field(
1077                                    "maxAnkleHeightMS",
1078                                ),
1079                            );
1080                            #[cfg(not(feature = "strict"))] Default::default()
1081                        }
1082                    };
1083                    let m_minAnkleHeightMS = match m_minAnkleHeightMS {
1084                        _serde::__private::Some(__field) => __field,
1085                        _serde::__private::None => {
1086                            #[cfg(feature = "strict")]
1087                            return _serde::__private::Err(
1088                                <__A::Error as _serde::de::Error>::missing_field(
1089                                    "minAnkleHeightMS",
1090                                ),
1091                            );
1092                            #[cfg(not(feature = "strict"))] Default::default()
1093                        }
1094                    };
1095                    let m_maxKneeAngleDegrees = match m_maxKneeAngleDegrees {
1096                        _serde::__private::Some(__field) => __field,
1097                        _serde::__private::None => {
1098                            #[cfg(feature = "strict")]
1099                            return _serde::__private::Err(
1100                                <__A::Error as _serde::de::Error>::missing_field(
1101                                    "maxKneeAngleDegrees",
1102                                ),
1103                            );
1104                            #[cfg(not(feature = "strict"))] Default::default()
1105                        }
1106                    };
1107                    let m_minKneeAngleDegrees = match m_minKneeAngleDegrees {
1108                        _serde::__private::Some(__field) => __field,
1109                        _serde::__private::None => {
1110                            #[cfg(feature = "strict")]
1111                            return _serde::__private::Err(
1112                                <__A::Error as _serde::de::Error>::missing_field(
1113                                    "minKneeAngleDegrees",
1114                                ),
1115                            );
1116                            #[cfg(not(feature = "strict"))] Default::default()
1117                        }
1118                    };
1119                    let m_maxAnkleAngleDegrees = match m_maxAnkleAngleDegrees {
1120                        _serde::__private::Some(__field) => __field,
1121                        _serde::__private::None => {
1122                            #[cfg(feature = "strict")]
1123                            return _serde::__private::Err(
1124                                <__A::Error as _serde::de::Error>::missing_field(
1125                                    "maxAnkleAngleDegrees",
1126                                ),
1127                            );
1128                            #[cfg(not(feature = "strict"))] Default::default()
1129                        }
1130                    };
1131                    let m_hipIndex = match m_hipIndex {
1132                        _serde::__private::Some(__field) => __field,
1133                        _serde::__private::None => {
1134                            #[cfg(feature = "strict")]
1135                            return _serde::__private::Err(
1136                                <__A::Error as _serde::de::Error>::missing_field("hipIndex"),
1137                            );
1138                            #[cfg(not(feature = "strict"))] Default::default()
1139                        }
1140                    };
1141                    let m_kneeIndex = match m_kneeIndex {
1142                        _serde::__private::Some(__field) => __field,
1143                        _serde::__private::None => {
1144                            #[cfg(feature = "strict")]
1145                            return _serde::__private::Err(
1146                                <__A::Error as _serde::de::Error>::missing_field(
1147                                    "kneeIndex",
1148                                ),
1149                            );
1150                            #[cfg(not(feature = "strict"))] Default::default()
1151                        }
1152                    };
1153                    let m_ankleIndex = match m_ankleIndex {
1154                        _serde::__private::Some(__field) => __field,
1155                        _serde::__private::None => {
1156                            #[cfg(feature = "strict")]
1157                            return _serde::__private::Err(
1158                                <__A::Error as _serde::de::Error>::missing_field(
1159                                    "ankleIndex",
1160                                ),
1161                            );
1162                            #[cfg(not(feature = "strict"))] Default::default()
1163                        }
1164                    };
1165                    let __ptr = __A::class_ptr(&mut __map);
1166                    _serde::__private::Ok(hkbFootIkDriverInfoLeg {
1167                        __ptr,
1168                        m_kneeAxisLS,
1169                        m_footEndLS,
1170                        m_footPlantedAnkleHeightMS,
1171                        m_footRaisedAnkleHeightMS,
1172                        m_maxAnkleHeightMS,
1173                        m_minAnkleHeightMS,
1174                        m_maxKneeAngleDegrees,
1175                        m_minKneeAngleDegrees,
1176                        m_maxAnkleAngleDegrees,
1177                        m_hipIndex,
1178                        m_kneeIndex,
1179                        m_ankleIndex,
1180                        ..Default::default()
1181                    })
1182                }
1183            }
1184            const FIELDS: &[&str] = &[
1185                "prevAnkleRotLS",
1186                "kneeAxisLS",
1187                "footEndLS",
1188                "footPlantedAnkleHeightMS",
1189                "footRaisedAnkleHeightMS",
1190                "maxAnkleHeightMS",
1191                "minAnkleHeightMS",
1192                "maxKneeAngleDegrees",
1193                "minKneeAngleDegrees",
1194                "maxAnkleAngleDegrees",
1195                "hipIndex",
1196                "kneeIndex",
1197                "ankleIndex",
1198            ];
1199            _serde::Deserializer::deserialize_struct(
1200                deserializer,
1201                "hkbFootIkDriverInfoLeg",
1202                FIELDS,
1203                __hkbFootIkDriverInfoLegVisitor {
1204                    marker: _serde::__private::PhantomData::<hkbFootIkDriverInfoLeg>,
1205                    lifetime: _serde::__private::PhantomData,
1206                },
1207            )
1208        }
1209    }
1210};