havok_classes/generated/
hkbFootIkDriverInfo_.rs

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