havok_classes/generated/
hkbFootIkGains_.rs

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