havok_classes/generated/
hkbFootIkModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbFootIkModifier`
5/// - version: `3`
6/// - signature: `0xed8966c0`
7/// - size: `208`(x86)/`256`(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 hkbFootIkModifier<'a> {
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    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkbModifier<'a>,
31    /// # C++ Info
32    /// - name: `gains`(ctype: `struct hkbFootIkGains`)
33    /// - offset: ` 44`(x86)/` 80`(x86_64)
34    /// - type_size: ` 48`(x86)/` 48`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "gains"))]
36    #[cfg_attr(feature = "serde", serde(rename = "gains"))]
37    pub m_gains: hkbFootIkGains,
38    /// # C++ Info
39    /// - name: `legs`(ctype: `hkArray<struct hkbFootIkModifierLeg>`)
40    /// - offset: ` 92`(x86)/`128`(x86_64)
41    /// - type_size: ` 12`(x86)/` 16`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "legs"))]
43    #[cfg_attr(feature = "serde", serde(rename = "legs"))]
44    pub m_legs: Vec<hkbFootIkModifierLeg>,
45    /// # C++ Info
46    /// - name: `raycastDistanceUp`(ctype: `hkReal`)
47    /// - offset: `104`(x86)/`144`(x86_64)
48    /// - type_size: `  4`(x86)/`  4`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "raycastDistanceUp"))]
50    #[cfg_attr(feature = "serde", serde(rename = "raycastDistanceUp"))]
51    pub m_raycastDistanceUp: f32,
52    /// # C++ Info
53    /// - name: `raycastDistanceDown`(ctype: `hkReal`)
54    /// - offset: `108`(x86)/`148`(x86_64)
55    /// - type_size: `  4`(x86)/`  4`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "raycastDistanceDown"))]
57    #[cfg_attr(feature = "serde", serde(rename = "raycastDistanceDown"))]
58    pub m_raycastDistanceDown: f32,
59    /// # C++ Info
60    /// - name: `originalGroundHeightMS`(ctype: `hkReal`)
61    /// - offset: `112`(x86)/`152`(x86_64)
62    /// - type_size: `  4`(x86)/`  4`(x86_64)
63    #[cfg_attr(feature = "json_schema", schemars(rename = "originalGroundHeightMS"))]
64    #[cfg_attr(feature = "serde", serde(rename = "originalGroundHeightMS"))]
65    pub m_originalGroundHeightMS: f32,
66    /// # C++ Info
67    /// - name: `errorOut`(ctype: `hkReal`)
68    /// - offset: `116`(x86)/`156`(x86_64)
69    /// - type_size: `  4`(x86)/`  4`(x86_64)
70    #[cfg_attr(feature = "json_schema", schemars(rename = "errorOut"))]
71    #[cfg_attr(feature = "serde", serde(rename = "errorOut"))]
72    pub m_errorOut: f32,
73    /// # C++ Info
74    /// - name: `errorOutTranslation`(ctype: `hkVector4`)
75    /// - offset: `128`(x86)/`160`(x86_64)
76    /// - type_size: ` 16`(x86)/` 16`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "errorOutTranslation"))]
78    #[cfg_attr(feature = "serde", serde(rename = "errorOutTranslation"))]
79    pub m_errorOutTranslation: Vector4,
80    /// # C++ Info
81    /// - name: `alignWithGroundRotation`(ctype: `hkQuaternion`)
82    /// - offset: `144`(x86)/`176`(x86_64)
83    /// - type_size: ` 16`(x86)/` 16`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "alignWithGroundRotation"))]
85    #[cfg_attr(feature = "serde", serde(rename = "alignWithGroundRotation"))]
86    pub m_alignWithGroundRotation: Quaternion,
87    /// # C++ Info
88    /// - name: `verticalOffset`(ctype: `hkReal`)
89    /// - offset: `160`(x86)/`192`(x86_64)
90    /// - type_size: `  4`(x86)/`  4`(x86_64)
91    #[cfg_attr(feature = "json_schema", schemars(rename = "verticalOffset"))]
92    #[cfg_attr(feature = "serde", serde(rename = "verticalOffset"))]
93    pub m_verticalOffset: f32,
94    /// # C++ Info
95    /// - name: `collisionFilterInfo`(ctype: `hkUint32`)
96    /// - offset: `164`(x86)/`196`(x86_64)
97    /// - type_size: `  4`(x86)/`  4`(x86_64)
98    #[cfg_attr(feature = "json_schema", schemars(rename = "collisionFilterInfo"))]
99    #[cfg_attr(feature = "serde", serde(rename = "collisionFilterInfo"))]
100    pub m_collisionFilterInfo: u32,
101    /// # C++ Info
102    /// - name: `forwardAlignFraction`(ctype: `hkReal`)
103    /// - offset: `168`(x86)/`200`(x86_64)
104    /// - type_size: `  4`(x86)/`  4`(x86_64)
105    #[cfg_attr(feature = "json_schema", schemars(rename = "forwardAlignFraction"))]
106    #[cfg_attr(feature = "serde", serde(rename = "forwardAlignFraction"))]
107    pub m_forwardAlignFraction: f32,
108    /// # C++ Info
109    /// - name: `sidewaysAlignFraction`(ctype: `hkReal`)
110    /// - offset: `172`(x86)/`204`(x86_64)
111    /// - type_size: `  4`(x86)/`  4`(x86_64)
112    #[cfg_attr(feature = "json_schema", schemars(rename = "sidewaysAlignFraction"))]
113    #[cfg_attr(feature = "serde", serde(rename = "sidewaysAlignFraction"))]
114    pub m_sidewaysAlignFraction: f32,
115    /// # C++ Info
116    /// - name: `sidewaysSampleWidth`(ctype: `hkReal`)
117    /// - offset: `176`(x86)/`208`(x86_64)
118    /// - type_size: `  4`(x86)/`  4`(x86_64)
119    #[cfg_attr(feature = "json_schema", schemars(rename = "sidewaysSampleWidth"))]
120    #[cfg_attr(feature = "serde", serde(rename = "sidewaysSampleWidth"))]
121    pub m_sidewaysSampleWidth: f32,
122    /// # C++ Info
123    /// - name: `useTrackData`(ctype: `hkBool`)
124    /// - offset: `180`(x86)/`212`(x86_64)
125    /// - type_size: `  1`(x86)/`  1`(x86_64)
126    #[cfg_attr(feature = "json_schema", schemars(rename = "useTrackData"))]
127    #[cfg_attr(feature = "serde", serde(rename = "useTrackData"))]
128    pub m_useTrackData: bool,
129    /// # C++ Info
130    /// - name: `lockFeetWhenPlanted`(ctype: `hkBool`)
131    /// - offset: `181`(x86)/`213`(x86_64)
132    /// - type_size: `  1`(x86)/`  1`(x86_64)
133    #[cfg_attr(feature = "json_schema", schemars(rename = "lockFeetWhenPlanted"))]
134    #[cfg_attr(feature = "serde", serde(rename = "lockFeetWhenPlanted"))]
135    pub m_lockFeetWhenPlanted: bool,
136    /// # C++ Info
137    /// - name: `useCharacterUpVector`(ctype: `hkBool`)
138    /// - offset: `182`(x86)/`214`(x86_64)
139    /// - type_size: `  1`(x86)/`  1`(x86_64)
140    #[cfg_attr(feature = "json_schema", schemars(rename = "useCharacterUpVector"))]
141    #[cfg_attr(feature = "serde", serde(rename = "useCharacterUpVector"))]
142    pub m_useCharacterUpVector: bool,
143    /// # C++ Info
144    /// - name: `alignMode`(ctype: `enum AlignMode`)
145    /// - offset: `183`(x86)/`215`(x86_64)
146    /// - type_size: `  1`(x86)/`  1`(x86_64)
147    #[cfg_attr(feature = "json_schema", schemars(rename = "alignMode"))]
148    #[cfg_attr(feature = "serde", serde(rename = "alignMode"))]
149    pub m_alignMode: AlignMode,
150    /// # C++ Info
151    /// - name: `internalLegData`(ctype: `hkArray<struct hkbFootIkModifierInternalLegData>`)
152    /// - offset: `184`(x86)/`216`(x86_64)
153    /// - type_size: ` 12`(x86)/` 16`(x86_64)
154    /// - flags: `SERIALIZE_IGNORED`
155    #[cfg_attr(feature = "json_schema", schemars(rename = "internalLegData"))]
156    #[cfg_attr(feature = "serde", serde(rename = "internalLegData"))]
157    pub m_internalLegData: Vec<hkbFootIkModifierInternalLegData>,
158    /// # C++ Info
159    /// - name: `prevIsFootIkEnabled`(ctype: `hkReal`)
160    /// - offset: `196`(x86)/`232`(x86_64)
161    /// - type_size: `  4`(x86)/`  4`(x86_64)
162    /// - flags: `SERIALIZE_IGNORED`
163    #[cfg_attr(feature = "json_schema", schemars(rename = "prevIsFootIkEnabled"))]
164    #[cfg_attr(feature = "serde", serde(rename = "prevIsFootIkEnabled"))]
165    pub m_prevIsFootIkEnabled: f32,
166    /// # C++ Info
167    /// - name: `isSetUp`(ctype: `hkBool`)
168    /// - offset: `200`(x86)/`236`(x86_64)
169    /// - type_size: `  1`(x86)/`  1`(x86_64)
170    /// - flags: `SERIALIZE_IGNORED`
171    #[cfg_attr(feature = "json_schema", schemars(rename = "isSetUp"))]
172    #[cfg_attr(feature = "serde", serde(rename = "isSetUp"))]
173    pub m_isSetUp: bool,
174    /// # C++ Info
175    /// - name: `isGroundPositionValid`(ctype: `hkBool`)
176    /// - offset: `201`(x86)/`237`(x86_64)
177    /// - type_size: `  1`(x86)/`  1`(x86_64)
178    /// - flags: `SERIALIZE_IGNORED`
179    #[cfg_attr(feature = "json_schema", schemars(rename = "isGroundPositionValid"))]
180    #[cfg_attr(feature = "serde", serde(rename = "isGroundPositionValid"))]
181    pub m_isGroundPositionValid: bool,
182    /// # C++ Info
183    /// - name: `timeStep`(ctype: `hkReal`)
184    /// - offset: `204`(x86)/`240`(x86_64)
185    /// - type_size: `  4`(x86)/`  4`(x86_64)
186    /// - flags: `SERIALIZE_IGNORED`
187    #[cfg_attr(feature = "json_schema", schemars(rename = "timeStep"))]
188    #[cfg_attr(feature = "serde", serde(rename = "timeStep"))]
189    pub m_timeStep: f32,
190}
191const _: () = {
192    use havok_serde as _serde;
193    impl<'a> _serde::HavokClass for hkbFootIkModifier<'a> {
194        #[inline]
195        fn name(&self) -> &'static str {
196            "hkbFootIkModifier"
197        }
198        #[inline]
199        fn signature(&self) -> _serde::__private::Signature {
200            _serde::__private::Signature::new(0xed8966c0)
201        }
202        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
203        fn deps_indexes(&self) -> Vec<usize> {
204            let mut v = Vec::new();
205            v.push(self.parent.parent.parent.m_variableBindingSet.get());
206            v.extend(self.m_gains.deps_indexes());
207            v.extend(
208                self
209                    .m_legs
210                    .iter()
211                    .flat_map(|class| class.deps_indexes())
212                    .collect::<Vec<usize>>(),
213            );
214            v.extend(
215                self
216                    .m_internalLegData
217                    .iter()
218                    .flat_map(|class| class.deps_indexes())
219                    .collect::<Vec<usize>>(),
220            );
221            v
222        }
223    }
224    impl<'a> _serde::Serialize for hkbFootIkModifier<'a> {
225        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
226        where
227            S: _serde::ser::Serializer,
228        {
229            let class_meta = self
230                .__ptr
231                .map(|name| (name, _serde::__private::Signature::new(0xed8966c0)));
232            let mut serializer = __serializer
233                .serialize_struct("hkbFootIkModifier", class_meta, (208u64, 256u64))?;
234            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
235            serializer
236                .skip_field(
237                    "memSizeAndFlags",
238                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
239                )?;
240            serializer
241                .skip_field(
242                    "referenceCount",
243                    &self.parent.parent.parent.parent.m_referenceCount,
244                )?;
245            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
246            serializer
247                .serialize_field(
248                    "variableBindingSet",
249                    &self.parent.parent.parent.m_variableBindingSet,
250                )?;
251            serializer
252                .skip_array_field(
253                    "cachedBindables",
254                    &self.parent.parent.parent.m_cachedBindables,
255                    TypeSize::NonPtr,
256                )?;
257            serializer
258                .skip_field(
259                    "areBindablesCached",
260                    &self.parent.parent.parent.m_areBindablesCached,
261                )?;
262            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
263            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
264            serializer.serialize_field("name", &self.parent.parent.m_name)?;
265            serializer.skip_field("id", &self.parent.parent.m_id)?;
266            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
267            serializer
268                .skip_fixed_array_field(
269                    "padNode",
270                    self.parent.parent.m_padNode.as_slice(),
271                    TypeSize::NonPtr,
272                )?;
273            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
274            serializer.serialize_field("enable", &self.parent.m_enable)?;
275            serializer
276                .skip_fixed_array_field(
277                    "padModifier",
278                    self.parent.m_padModifier.as_slice(),
279                    TypeSize::NonPtr,
280                )?;
281            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
282            serializer.serialize_field("gains", &self.m_gains)?;
283            serializer
284                .serialize_array_field(
285                    "legs",
286                    &self.m_legs,
287                    TypeSize::Struct {
288                        size_x86: 160u64,
289                        size_x86_64: 160u64,
290                    },
291                )?;
292            serializer.serialize_field("raycastDistanceUp", &self.m_raycastDistanceUp)?;
293            serializer
294                .serialize_field("raycastDistanceDown", &self.m_raycastDistanceDown)?;
295            serializer
296                .serialize_field(
297                    "originalGroundHeightMS",
298                    &self.m_originalGroundHeightMS,
299                )?;
300            serializer.serialize_field("errorOut", &self.m_errorOut)?;
301            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
302            serializer
303                .serialize_field("errorOutTranslation", &self.m_errorOutTranslation)?;
304            serializer
305                .serialize_field(
306                    "alignWithGroundRotation",
307                    &self.m_alignWithGroundRotation,
308                )?;
309            serializer.serialize_field("verticalOffset", &self.m_verticalOffset)?;
310            serializer
311                .serialize_field("collisionFilterInfo", &self.m_collisionFilterInfo)?;
312            serializer
313                .serialize_field("forwardAlignFraction", &self.m_forwardAlignFraction)?;
314            serializer
315                .serialize_field(
316                    "sidewaysAlignFraction",
317                    &self.m_sidewaysAlignFraction,
318                )?;
319            serializer
320                .serialize_field("sidewaysSampleWidth", &self.m_sidewaysSampleWidth)?;
321            serializer.serialize_field("useTrackData", &self.m_useTrackData)?;
322            serializer
323                .serialize_field("lockFeetWhenPlanted", &self.m_lockFeetWhenPlanted)?;
324            serializer
325                .serialize_field("useCharacterUpVector", &self.m_useCharacterUpVector)?;
326            serializer.serialize_field("alignMode", &self.m_alignMode)?;
327            serializer
328                .skip_array_field(
329                    "internalLegData",
330                    &self.m_internalLegData,
331                    TypeSize::Struct {
332                        size_x86: 32u64,
333                        size_x86_64: 32u64,
334                    },
335                )?;
336            serializer.skip_field("prevIsFootIkEnabled", &self.m_prevIsFootIkEnabled)?;
337            serializer.skip_field("isSetUp", &self.m_isSetUp)?;
338            serializer
339                .skip_field("isGroundPositionValid", &self.m_isGroundPositionValid)?;
340            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
341            serializer.skip_field("timeStep", &self.m_timeStep)?;
342            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 12usize].as_slice())?;
343            serializer.end()
344        }
345    }
346};
347#[doc(hidden)]
348#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
349const _: () = {
350    use havok_serde as _serde;
351    #[automatically_derived]
352    impl<'de> _serde::Deserialize<'de> for hkbFootIkModifier<'de> {
353        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
354        where
355            __D: _serde::Deserializer<'de>,
356        {
357            #[allow(non_camel_case_types)]
358            enum __Field {
359                m_variableBindingSet,
360                m_userData,
361                m_name,
362                m_enable,
363                m_gains,
364                m_legs,
365                m_raycastDistanceUp,
366                m_raycastDistanceDown,
367                m_originalGroundHeightMS,
368                m_errorOut,
369                m_errorOutTranslation,
370                m_alignWithGroundRotation,
371                m_verticalOffset,
372                m_collisionFilterInfo,
373                m_forwardAlignFraction,
374                m_sidewaysAlignFraction,
375                m_sidewaysSampleWidth,
376                m_useTrackData,
377                m_lockFeetWhenPlanted,
378                m_useCharacterUpVector,
379                m_alignMode,
380                __ignore,
381            }
382            struct __FieldVisitor;
383            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
384                type Value = __Field;
385                fn expecting(
386                    &self,
387                    __formatter: &mut core::fmt::Formatter,
388                ) -> core::fmt::Result {
389                    core::fmt::Formatter::write_str(__formatter, "field identifier")
390                }
391                /// Intended for use in XML.
392                #[allow(clippy::match_single_binding)]
393                #[allow(clippy::reversed_empty_ranges)]
394                #[allow(clippy::single_match)]
395                fn visit_key<__E>(
396                    self,
397                    __value: &str,
398                ) -> core::result::Result<Self::Value, __E>
399                where
400                    __E: _serde::de::Error,
401                {
402                    match __value {
403                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
404                        "userData" => Ok(__Field::m_userData),
405                        "name" => Ok(__Field::m_name),
406                        "enable" => Ok(__Field::m_enable),
407                        "gains" => Ok(__Field::m_gains),
408                        "legs" => Ok(__Field::m_legs),
409                        "raycastDistanceUp" => Ok(__Field::m_raycastDistanceUp),
410                        "raycastDistanceDown" => Ok(__Field::m_raycastDistanceDown),
411                        "originalGroundHeightMS" => Ok(__Field::m_originalGroundHeightMS),
412                        "errorOut" => Ok(__Field::m_errorOut),
413                        "errorOutTranslation" => Ok(__Field::m_errorOutTranslation),
414                        "alignWithGroundRotation" => {
415                            Ok(__Field::m_alignWithGroundRotation)
416                        }
417                        "verticalOffset" => Ok(__Field::m_verticalOffset),
418                        "collisionFilterInfo" => Ok(__Field::m_collisionFilterInfo),
419                        "forwardAlignFraction" => Ok(__Field::m_forwardAlignFraction),
420                        "sidewaysAlignFraction" => Ok(__Field::m_sidewaysAlignFraction),
421                        "sidewaysSampleWidth" => Ok(__Field::m_sidewaysSampleWidth),
422                        "useTrackData" => Ok(__Field::m_useTrackData),
423                        "lockFeetWhenPlanted" => Ok(__Field::m_lockFeetWhenPlanted),
424                        "useCharacterUpVector" => Ok(__Field::m_useCharacterUpVector),
425                        "alignMode" => Ok(__Field::m_alignMode),
426                        _ => Ok(__Field::__ignore),
427                    }
428                }
429            }
430            impl<'de> _serde::Deserialize<'de> for __Field {
431                #[inline]
432                fn deserialize<__D>(
433                    __deserializer: __D,
434                ) -> core::result::Result<Self, __D::Error>
435                where
436                    __D: _serde::Deserializer<'de>,
437                {
438                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
439                }
440            }
441            struct __hkbFootIkModifierVisitor<'de> {
442                marker: _serde::__private::PhantomData<hkbFootIkModifier<'de>>,
443                lifetime: _serde::__private::PhantomData<&'de ()>,
444            }
445            #[allow(clippy::match_single_binding)]
446            #[allow(clippy::reversed_empty_ranges)]
447            #[allow(clippy::single_match)]
448            impl<'de> _serde::de::Visitor<'de> for __hkbFootIkModifierVisitor<'de> {
449                type Value = hkbFootIkModifier<'de>;
450                fn expecting(
451                    &self,
452                    __formatter: &mut core::fmt::Formatter,
453                ) -> core::fmt::Result {
454                    core::fmt::Formatter::write_str(
455                        __formatter,
456                        "struct hkbFootIkModifier",
457                    )
458                }
459                fn visit_struct_for_bytes<__A>(
460                    self,
461                    mut __map: __A,
462                ) -> _serde::__private::Result<Self::Value, __A::Error>
463                where
464                    __A: _serde::de::MapAccess<'de>,
465                {
466                    let __ptr = __A::class_ptr(&mut __map);
467                    let parent = __A::parent_value(&mut __map)?;
468                    let mut m_gains: _serde::__private::Option<hkbFootIkGains> = _serde::__private::None;
469                    let mut m_legs: _serde::__private::Option<
470                        Vec<hkbFootIkModifierLeg>,
471                    > = _serde::__private::None;
472                    let mut m_raycastDistanceUp: _serde::__private::Option<f32> = _serde::__private::None;
473                    let mut m_raycastDistanceDown: _serde::__private::Option<f32> = _serde::__private::None;
474                    let mut m_originalGroundHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
475                    let mut m_errorOut: _serde::__private::Option<f32> = _serde::__private::None;
476                    let mut m_errorOutTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
477                    let mut m_alignWithGroundRotation: _serde::__private::Option<
478                        Quaternion,
479                    > = _serde::__private::None;
480                    let mut m_verticalOffset: _serde::__private::Option<f32> = _serde::__private::None;
481                    let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
482                    let mut m_forwardAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
483                    let mut m_sidewaysAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
484                    let mut m_sidewaysSampleWidth: _serde::__private::Option<f32> = _serde::__private::None;
485                    let mut m_useTrackData: _serde::__private::Option<bool> = _serde::__private::None;
486                    let mut m_lockFeetWhenPlanted: _serde::__private::Option<bool> = _serde::__private::None;
487                    let mut m_useCharacterUpVector: _serde::__private::Option<bool> = _serde::__private::None;
488                    let mut m_alignMode: _serde::__private::Option<AlignMode> = _serde::__private::None;
489                    let mut m_internalLegData: _serde::__private::Option<
490                        Vec<hkbFootIkModifierInternalLegData>,
491                    > = _serde::__private::None;
492                    let mut m_prevIsFootIkEnabled: _serde::__private::Option<f32> = _serde::__private::None;
493                    let mut m_isSetUp: _serde::__private::Option<bool> = _serde::__private::None;
494                    let mut m_isGroundPositionValid: _serde::__private::Option<bool> = _serde::__private::None;
495                    let mut m_timeStep: _serde::__private::Option<f32> = _serde::__private::None;
496                    for i in 0..22usize {
497                        match i {
498                            0usize => {
499                                if _serde::__private::Option::is_some(&m_gains) {
500                                    return _serde::__private::Err(
501                                        <__A::Error as _serde::de::Error>::duplicate_field("gains"),
502                                    );
503                                }
504                                m_gains = _serde::__private::Some(
505                                    match __A::next_value::<hkbFootIkGains>(&mut __map) {
506                                        _serde::__private::Ok(__val) => __val,
507                                        _serde::__private::Err(__err) => {
508                                            return _serde::__private::Err(__err);
509                                        }
510                                    },
511                                );
512                            }
513                            1usize => {
514                                if _serde::__private::Option::is_some(&m_legs) {
515                                    return _serde::__private::Err(
516                                        <__A::Error as _serde::de::Error>::duplicate_field("legs"),
517                                    );
518                                }
519                                m_legs = _serde::__private::Some(
520                                    match __A::next_value::<
521                                        Vec<hkbFootIkModifierLeg>,
522                                    >(&mut __map) {
523                                        _serde::__private::Ok(__val) => __val,
524                                        _serde::__private::Err(__err) => {
525                                            return _serde::__private::Err(__err);
526                                        }
527                                    },
528                                );
529                            }
530                            2usize => {
531                                if _serde::__private::Option::is_some(
532                                    &m_raycastDistanceUp,
533                                ) {
534                                    return _serde::__private::Err(
535                                        <__A::Error as _serde::de::Error>::duplicate_field(
536                                            "raycastDistanceUp",
537                                        ),
538                                    );
539                                }
540                                m_raycastDistanceUp = _serde::__private::Some(
541                                    match __A::next_value::<f32>(&mut __map) {
542                                        _serde::__private::Ok(__val) => __val,
543                                        _serde::__private::Err(__err) => {
544                                            return _serde::__private::Err(__err);
545                                        }
546                                    },
547                                );
548                            }
549                            3usize => {
550                                if _serde::__private::Option::is_some(
551                                    &m_raycastDistanceDown,
552                                ) {
553                                    return _serde::__private::Err(
554                                        <__A::Error as _serde::de::Error>::duplicate_field(
555                                            "raycastDistanceDown",
556                                        ),
557                                    );
558                                }
559                                m_raycastDistanceDown = _serde::__private::Some(
560                                    match __A::next_value::<f32>(&mut __map) {
561                                        _serde::__private::Ok(__val) => __val,
562                                        _serde::__private::Err(__err) => {
563                                            return _serde::__private::Err(__err);
564                                        }
565                                    },
566                                );
567                            }
568                            4usize => {
569                                if _serde::__private::Option::is_some(
570                                    &m_originalGroundHeightMS,
571                                ) {
572                                    return _serde::__private::Err(
573                                        <__A::Error as _serde::de::Error>::duplicate_field(
574                                            "originalGroundHeightMS",
575                                        ),
576                                    );
577                                }
578                                m_originalGroundHeightMS = _serde::__private::Some(
579                                    match __A::next_value::<f32>(&mut __map) {
580                                        _serde::__private::Ok(__val) => __val,
581                                        _serde::__private::Err(__err) => {
582                                            return _serde::__private::Err(__err);
583                                        }
584                                    },
585                                );
586                            }
587                            5usize => {
588                                if _serde::__private::Option::is_some(&m_errorOut) {
589                                    return _serde::__private::Err(
590                                        <__A::Error as _serde::de::Error>::duplicate_field(
591                                            "errorOut",
592                                        ),
593                                    );
594                                }
595                                m_errorOut = _serde::__private::Some(
596                                    match __A::next_value::<f32>(&mut __map) {
597                                        _serde::__private::Ok(__val) => __val,
598                                        _serde::__private::Err(__err) => {
599                                            return _serde::__private::Err(__err);
600                                        }
601                                    },
602                                );
603                            }
604                            6usize => {
605                                if _serde::__private::Option::is_some(
606                                    &m_errorOutTranslation,
607                                ) {
608                                    return _serde::__private::Err(
609                                        <__A::Error as _serde::de::Error>::duplicate_field(
610                                            "errorOutTranslation",
611                                        ),
612                                    );
613                                }
614                                __A::pad(&mut __map, 8usize, 0usize)?;
615                                m_errorOutTranslation = _serde::__private::Some(
616                                    match __A::next_value::<Vector4>(&mut __map) {
617                                        _serde::__private::Ok(__val) => __val,
618                                        _serde::__private::Err(__err) => {
619                                            return _serde::__private::Err(__err);
620                                        }
621                                    },
622                                );
623                            }
624                            7usize => {
625                                if _serde::__private::Option::is_some(
626                                    &m_alignWithGroundRotation,
627                                ) {
628                                    return _serde::__private::Err(
629                                        <__A::Error as _serde::de::Error>::duplicate_field(
630                                            "alignWithGroundRotation",
631                                        ),
632                                    );
633                                }
634                                m_alignWithGroundRotation = _serde::__private::Some(
635                                    match __A::next_value::<Quaternion>(&mut __map) {
636                                        _serde::__private::Ok(__val) => __val,
637                                        _serde::__private::Err(__err) => {
638                                            return _serde::__private::Err(__err);
639                                        }
640                                    },
641                                );
642                            }
643                            8usize => {
644                                if _serde::__private::Option::is_some(&m_verticalOffset) {
645                                    return _serde::__private::Err(
646                                        <__A::Error as _serde::de::Error>::duplicate_field(
647                                            "verticalOffset",
648                                        ),
649                                    );
650                                }
651                                m_verticalOffset = _serde::__private::Some(
652                                    match __A::next_value::<f32>(&mut __map) {
653                                        _serde::__private::Ok(__val) => __val,
654                                        _serde::__private::Err(__err) => {
655                                            return _serde::__private::Err(__err);
656                                        }
657                                    },
658                                );
659                            }
660                            9usize => {
661                                if _serde::__private::Option::is_some(
662                                    &m_collisionFilterInfo,
663                                ) {
664                                    return _serde::__private::Err(
665                                        <__A::Error as _serde::de::Error>::duplicate_field(
666                                            "collisionFilterInfo",
667                                        ),
668                                    );
669                                }
670                                m_collisionFilterInfo = _serde::__private::Some(
671                                    match __A::next_value::<u32>(&mut __map) {
672                                        _serde::__private::Ok(__val) => __val,
673                                        _serde::__private::Err(__err) => {
674                                            return _serde::__private::Err(__err);
675                                        }
676                                    },
677                                );
678                            }
679                            10usize => {
680                                if _serde::__private::Option::is_some(
681                                    &m_forwardAlignFraction,
682                                ) {
683                                    return _serde::__private::Err(
684                                        <__A::Error as _serde::de::Error>::duplicate_field(
685                                            "forwardAlignFraction",
686                                        ),
687                                    );
688                                }
689                                m_forwardAlignFraction = _serde::__private::Some(
690                                    match __A::next_value::<f32>(&mut __map) {
691                                        _serde::__private::Ok(__val) => __val,
692                                        _serde::__private::Err(__err) => {
693                                            return _serde::__private::Err(__err);
694                                        }
695                                    },
696                                );
697                            }
698                            11usize => {
699                                if _serde::__private::Option::is_some(
700                                    &m_sidewaysAlignFraction,
701                                ) {
702                                    return _serde::__private::Err(
703                                        <__A::Error as _serde::de::Error>::duplicate_field(
704                                            "sidewaysAlignFraction",
705                                        ),
706                                    );
707                                }
708                                m_sidewaysAlignFraction = _serde::__private::Some(
709                                    match __A::next_value::<f32>(&mut __map) {
710                                        _serde::__private::Ok(__val) => __val,
711                                        _serde::__private::Err(__err) => {
712                                            return _serde::__private::Err(__err);
713                                        }
714                                    },
715                                );
716                            }
717                            12usize => {
718                                if _serde::__private::Option::is_some(
719                                    &m_sidewaysSampleWidth,
720                                ) {
721                                    return _serde::__private::Err(
722                                        <__A::Error as _serde::de::Error>::duplicate_field(
723                                            "sidewaysSampleWidth",
724                                        ),
725                                    );
726                                }
727                                m_sidewaysSampleWidth = _serde::__private::Some(
728                                    match __A::next_value::<f32>(&mut __map) {
729                                        _serde::__private::Ok(__val) => __val,
730                                        _serde::__private::Err(__err) => {
731                                            return _serde::__private::Err(__err);
732                                        }
733                                    },
734                                );
735                            }
736                            13usize => {
737                                if _serde::__private::Option::is_some(&m_useTrackData) {
738                                    return _serde::__private::Err(
739                                        <__A::Error as _serde::de::Error>::duplicate_field(
740                                            "useTrackData",
741                                        ),
742                                    );
743                                }
744                                m_useTrackData = _serde::__private::Some(
745                                    match __A::next_value::<bool>(&mut __map) {
746                                        _serde::__private::Ok(__val) => __val,
747                                        _serde::__private::Err(__err) => {
748                                            return _serde::__private::Err(__err);
749                                        }
750                                    },
751                                );
752                            }
753                            14usize => {
754                                if _serde::__private::Option::is_some(
755                                    &m_lockFeetWhenPlanted,
756                                ) {
757                                    return _serde::__private::Err(
758                                        <__A::Error as _serde::de::Error>::duplicate_field(
759                                            "lockFeetWhenPlanted",
760                                        ),
761                                    );
762                                }
763                                m_lockFeetWhenPlanted = _serde::__private::Some(
764                                    match __A::next_value::<bool>(&mut __map) {
765                                        _serde::__private::Ok(__val) => __val,
766                                        _serde::__private::Err(__err) => {
767                                            return _serde::__private::Err(__err);
768                                        }
769                                    },
770                                );
771                            }
772                            15usize => {
773                                if _serde::__private::Option::is_some(
774                                    &m_useCharacterUpVector,
775                                ) {
776                                    return _serde::__private::Err(
777                                        <__A::Error as _serde::de::Error>::duplicate_field(
778                                            "useCharacterUpVector",
779                                        ),
780                                    );
781                                }
782                                m_useCharacterUpVector = _serde::__private::Some(
783                                    match __A::next_value::<bool>(&mut __map) {
784                                        _serde::__private::Ok(__val) => __val,
785                                        _serde::__private::Err(__err) => {
786                                            return _serde::__private::Err(__err);
787                                        }
788                                    },
789                                );
790                            }
791                            16usize => {
792                                if _serde::__private::Option::is_some(&m_alignMode) {
793                                    return _serde::__private::Err(
794                                        <__A::Error as _serde::de::Error>::duplicate_field(
795                                            "alignMode",
796                                        ),
797                                    );
798                                }
799                                m_alignMode = _serde::__private::Some(
800                                    match __A::next_value::<AlignMode>(&mut __map) {
801                                        _serde::__private::Ok(__val) => __val,
802                                        _serde::__private::Err(__err) => {
803                                            return _serde::__private::Err(__err);
804                                        }
805                                    },
806                                );
807                            }
808                            17usize => {
809                                if _serde::__private::Option::is_some(&m_internalLegData) {
810                                    return _serde::__private::Err(
811                                        <__A::Error as _serde::de::Error>::duplicate_field(
812                                            "internalLegData",
813                                        ),
814                                    );
815                                }
816                                m_internalLegData = _serde::__private::Some(
817                                    match __A::next_value::<
818                                        Vec<hkbFootIkModifierInternalLegData>,
819                                    >(&mut __map) {
820                                        _serde::__private::Ok(__val) => __val,
821                                        _serde::__private::Err(__err) => {
822                                            return _serde::__private::Err(__err);
823                                        }
824                                    },
825                                );
826                            }
827                            18usize => {
828                                if _serde::__private::Option::is_some(
829                                    &m_prevIsFootIkEnabled,
830                                ) {
831                                    return _serde::__private::Err(
832                                        <__A::Error as _serde::de::Error>::duplicate_field(
833                                            "prevIsFootIkEnabled",
834                                        ),
835                                    );
836                                }
837                                m_prevIsFootIkEnabled = _serde::__private::Some(
838                                    match __A::next_value::<f32>(&mut __map) {
839                                        _serde::__private::Ok(__val) => __val,
840                                        _serde::__private::Err(__err) => {
841                                            return _serde::__private::Err(__err);
842                                        }
843                                    },
844                                );
845                            }
846                            19usize => {
847                                if _serde::__private::Option::is_some(&m_isSetUp) {
848                                    return _serde::__private::Err(
849                                        <__A::Error as _serde::de::Error>::duplicate_field(
850                                            "isSetUp",
851                                        ),
852                                    );
853                                }
854                                m_isSetUp = _serde::__private::Some(
855                                    match __A::next_value::<bool>(&mut __map) {
856                                        _serde::__private::Ok(__val) => __val,
857                                        _serde::__private::Err(__err) => {
858                                            return _serde::__private::Err(__err);
859                                        }
860                                    },
861                                );
862                            }
863                            20usize => {
864                                if _serde::__private::Option::is_some(
865                                    &m_isGroundPositionValid,
866                                ) {
867                                    return _serde::__private::Err(
868                                        <__A::Error as _serde::de::Error>::duplicate_field(
869                                            "isGroundPositionValid",
870                                        ),
871                                    );
872                                }
873                                m_isGroundPositionValid = _serde::__private::Some(
874                                    match __A::next_value::<bool>(&mut __map) {
875                                        _serde::__private::Ok(__val) => __val,
876                                        _serde::__private::Err(__err) => {
877                                            return _serde::__private::Err(__err);
878                                        }
879                                    },
880                                );
881                            }
882                            21usize => {
883                                if _serde::__private::Option::is_some(&m_timeStep) {
884                                    return _serde::__private::Err(
885                                        <__A::Error as _serde::de::Error>::duplicate_field(
886                                            "timeStep",
887                                        ),
888                                    );
889                                }
890                                __A::pad(&mut __map, 2usize, 2usize)?;
891                                m_timeStep = _serde::__private::Some(
892                                    match __A::next_value::<f32>(&mut __map) {
893                                        _serde::__private::Ok(__val) => __val,
894                                        _serde::__private::Err(__err) => {
895                                            return _serde::__private::Err(__err);
896                                        }
897                                    },
898                                );
899                            }
900                            _ => {}
901                        }
902                    }
903                    __A::pad(&mut __map, 0usize, 12usize)?;
904                    let m_gains = match m_gains {
905                        _serde::__private::Some(__field) => __field,
906                        _serde::__private::None => {
907                            return _serde::__private::Err(
908                                <__A::Error as _serde::de::Error>::missing_field("gains"),
909                            );
910                        }
911                    };
912                    let m_legs = match m_legs {
913                        _serde::__private::Some(__field) => __field,
914                        _serde::__private::None => {
915                            return _serde::__private::Err(
916                                <__A::Error as _serde::de::Error>::missing_field("legs"),
917                            );
918                        }
919                    };
920                    let m_raycastDistanceUp = match m_raycastDistanceUp {
921                        _serde::__private::Some(__field) => __field,
922                        _serde::__private::None => {
923                            return _serde::__private::Err(
924                                <__A::Error as _serde::de::Error>::missing_field(
925                                    "raycastDistanceUp",
926                                ),
927                            );
928                        }
929                    };
930                    let m_raycastDistanceDown = match m_raycastDistanceDown {
931                        _serde::__private::Some(__field) => __field,
932                        _serde::__private::None => {
933                            return _serde::__private::Err(
934                                <__A::Error as _serde::de::Error>::missing_field(
935                                    "raycastDistanceDown",
936                                ),
937                            );
938                        }
939                    };
940                    let m_originalGroundHeightMS = match m_originalGroundHeightMS {
941                        _serde::__private::Some(__field) => __field,
942                        _serde::__private::None => {
943                            return _serde::__private::Err(
944                                <__A::Error as _serde::de::Error>::missing_field(
945                                    "originalGroundHeightMS",
946                                ),
947                            );
948                        }
949                    };
950                    let m_errorOut = match m_errorOut {
951                        _serde::__private::Some(__field) => __field,
952                        _serde::__private::None => {
953                            return _serde::__private::Err(
954                                <__A::Error as _serde::de::Error>::missing_field("errorOut"),
955                            );
956                        }
957                    };
958                    let m_errorOutTranslation = match m_errorOutTranslation {
959                        _serde::__private::Some(__field) => __field,
960                        _serde::__private::None => {
961                            return _serde::__private::Err(
962                                <__A::Error as _serde::de::Error>::missing_field(
963                                    "errorOutTranslation",
964                                ),
965                            );
966                        }
967                    };
968                    let m_alignWithGroundRotation = match m_alignWithGroundRotation {
969                        _serde::__private::Some(__field) => __field,
970                        _serde::__private::None => {
971                            return _serde::__private::Err(
972                                <__A::Error as _serde::de::Error>::missing_field(
973                                    "alignWithGroundRotation",
974                                ),
975                            );
976                        }
977                    };
978                    let m_verticalOffset = match m_verticalOffset {
979                        _serde::__private::Some(__field) => __field,
980                        _serde::__private::None => {
981                            return _serde::__private::Err(
982                                <__A::Error as _serde::de::Error>::missing_field(
983                                    "verticalOffset",
984                                ),
985                            );
986                        }
987                    };
988                    let m_collisionFilterInfo = match m_collisionFilterInfo {
989                        _serde::__private::Some(__field) => __field,
990                        _serde::__private::None => {
991                            return _serde::__private::Err(
992                                <__A::Error as _serde::de::Error>::missing_field(
993                                    "collisionFilterInfo",
994                                ),
995                            );
996                        }
997                    };
998                    let m_forwardAlignFraction = match m_forwardAlignFraction {
999                        _serde::__private::Some(__field) => __field,
1000                        _serde::__private::None => {
1001                            return _serde::__private::Err(
1002                                <__A::Error as _serde::de::Error>::missing_field(
1003                                    "forwardAlignFraction",
1004                                ),
1005                            );
1006                        }
1007                    };
1008                    let m_sidewaysAlignFraction = match m_sidewaysAlignFraction {
1009                        _serde::__private::Some(__field) => __field,
1010                        _serde::__private::None => {
1011                            return _serde::__private::Err(
1012                                <__A::Error as _serde::de::Error>::missing_field(
1013                                    "sidewaysAlignFraction",
1014                                ),
1015                            );
1016                        }
1017                    };
1018                    let m_sidewaysSampleWidth = match m_sidewaysSampleWidth {
1019                        _serde::__private::Some(__field) => __field,
1020                        _serde::__private::None => {
1021                            return _serde::__private::Err(
1022                                <__A::Error as _serde::de::Error>::missing_field(
1023                                    "sidewaysSampleWidth",
1024                                ),
1025                            );
1026                        }
1027                    };
1028                    let m_useTrackData = match m_useTrackData {
1029                        _serde::__private::Some(__field) => __field,
1030                        _serde::__private::None => {
1031                            return _serde::__private::Err(
1032                                <__A::Error as _serde::de::Error>::missing_field(
1033                                    "useTrackData",
1034                                ),
1035                            );
1036                        }
1037                    };
1038                    let m_lockFeetWhenPlanted = match m_lockFeetWhenPlanted {
1039                        _serde::__private::Some(__field) => __field,
1040                        _serde::__private::None => {
1041                            return _serde::__private::Err(
1042                                <__A::Error as _serde::de::Error>::missing_field(
1043                                    "lockFeetWhenPlanted",
1044                                ),
1045                            );
1046                        }
1047                    };
1048                    let m_useCharacterUpVector = match m_useCharacterUpVector {
1049                        _serde::__private::Some(__field) => __field,
1050                        _serde::__private::None => {
1051                            return _serde::__private::Err(
1052                                <__A::Error as _serde::de::Error>::missing_field(
1053                                    "useCharacterUpVector",
1054                                ),
1055                            );
1056                        }
1057                    };
1058                    let m_alignMode = match m_alignMode {
1059                        _serde::__private::Some(__field) => __field,
1060                        _serde::__private::None => {
1061                            return _serde::__private::Err(
1062                                <__A::Error as _serde::de::Error>::missing_field(
1063                                    "alignMode",
1064                                ),
1065                            );
1066                        }
1067                    };
1068                    let m_internalLegData = match m_internalLegData {
1069                        _serde::__private::Some(__field) => __field,
1070                        _serde::__private::None => {
1071                            return _serde::__private::Err(
1072                                <__A::Error as _serde::de::Error>::missing_field(
1073                                    "internalLegData",
1074                                ),
1075                            );
1076                        }
1077                    };
1078                    let m_prevIsFootIkEnabled = match m_prevIsFootIkEnabled {
1079                        _serde::__private::Some(__field) => __field,
1080                        _serde::__private::None => {
1081                            return _serde::__private::Err(
1082                                <__A::Error as _serde::de::Error>::missing_field(
1083                                    "prevIsFootIkEnabled",
1084                                ),
1085                            );
1086                        }
1087                    };
1088                    let m_isSetUp = match m_isSetUp {
1089                        _serde::__private::Some(__field) => __field,
1090                        _serde::__private::None => {
1091                            return _serde::__private::Err(
1092                                <__A::Error as _serde::de::Error>::missing_field("isSetUp"),
1093                            );
1094                        }
1095                    };
1096                    let m_isGroundPositionValid = match m_isGroundPositionValid {
1097                        _serde::__private::Some(__field) => __field,
1098                        _serde::__private::None => {
1099                            return _serde::__private::Err(
1100                                <__A::Error as _serde::de::Error>::missing_field(
1101                                    "isGroundPositionValid",
1102                                ),
1103                            );
1104                        }
1105                    };
1106                    let m_timeStep = match m_timeStep {
1107                        _serde::__private::Some(__field) => __field,
1108                        _serde::__private::None => {
1109                            return _serde::__private::Err(
1110                                <__A::Error as _serde::de::Error>::missing_field("timeStep"),
1111                            );
1112                        }
1113                    };
1114                    _serde::__private::Ok(hkbFootIkModifier {
1115                        __ptr,
1116                        parent,
1117                        m_gains,
1118                        m_legs,
1119                        m_raycastDistanceUp,
1120                        m_raycastDistanceDown,
1121                        m_originalGroundHeightMS,
1122                        m_errorOut,
1123                        m_errorOutTranslation,
1124                        m_alignWithGroundRotation,
1125                        m_verticalOffset,
1126                        m_collisionFilterInfo,
1127                        m_forwardAlignFraction,
1128                        m_sidewaysAlignFraction,
1129                        m_sidewaysSampleWidth,
1130                        m_useTrackData,
1131                        m_lockFeetWhenPlanted,
1132                        m_useCharacterUpVector,
1133                        m_alignMode,
1134                        m_internalLegData,
1135                        m_prevIsFootIkEnabled,
1136                        m_isSetUp,
1137                        m_isGroundPositionValid,
1138                        m_timeStep,
1139                    })
1140                }
1141                #[allow(clippy::manual_unwrap_or_default)]
1142                fn visit_struct<__A>(
1143                    self,
1144                    mut __map: __A,
1145                ) -> _serde::__private::Result<Self::Value, __A::Error>
1146                where
1147                    __A: _serde::de::MapAccess<'de>,
1148                {
1149                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1150                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1151                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1152                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
1153                    let mut m_gains: _serde::__private::Option<hkbFootIkGains> = _serde::__private::None;
1154                    let mut m_legs: _serde::__private::Option<
1155                        Vec<hkbFootIkModifierLeg>,
1156                    > = _serde::__private::None;
1157                    let mut m_raycastDistanceUp: _serde::__private::Option<f32> = _serde::__private::None;
1158                    let mut m_raycastDistanceDown: _serde::__private::Option<f32> = _serde::__private::None;
1159                    let mut m_originalGroundHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
1160                    let mut m_errorOut: _serde::__private::Option<f32> = _serde::__private::None;
1161                    let mut m_errorOutTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
1162                    let mut m_alignWithGroundRotation: _serde::__private::Option<
1163                        Quaternion,
1164                    > = _serde::__private::None;
1165                    let mut m_verticalOffset: _serde::__private::Option<f32> = _serde::__private::None;
1166                    let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
1167                    let mut m_forwardAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
1168                    let mut m_sidewaysAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
1169                    let mut m_sidewaysSampleWidth: _serde::__private::Option<f32> = _serde::__private::None;
1170                    let mut m_useTrackData: _serde::__private::Option<bool> = _serde::__private::None;
1171                    let mut m_lockFeetWhenPlanted: _serde::__private::Option<bool> = _serde::__private::None;
1172                    let mut m_useCharacterUpVector: _serde::__private::Option<bool> = _serde::__private::None;
1173                    let mut m_alignMode: _serde::__private::Option<AlignMode> = _serde::__private::None;
1174                    while let _serde::__private::Some(__key) = {
1175                        __A::next_key::<__Field>(&mut __map)?
1176                    } {
1177                        match __key {
1178                            __Field::m_variableBindingSet => {
1179                                #[cfg(
1180                                    any(feature = "strict", feature = "ignore_duplicates")
1181                                )]
1182                                if _serde::__private::Option::is_some(
1183                                    &m_variableBindingSet,
1184                                ) {
1185                                    #[cfg(feature = "ignore_duplicates")]
1186                                    {
1187                                        __A::skip_value(&mut __map)?;
1188                                        continue;
1189                                    }
1190                                    #[cfg(feature = "strict")]
1191                                    return _serde::__private::Err(
1192                                        <__A::Error as _serde::de::Error>::duplicate_field(
1193                                            "variableBindingSet",
1194                                        ),
1195                                    );
1196                                }
1197                                m_variableBindingSet = _serde::__private::Some(
1198                                    match __A::next_value::<Pointer>(&mut __map) {
1199                                        _serde::__private::Ok(__val) => __val,
1200                                        _serde::__private::Err(__err) => {
1201                                            return _serde::__private::Err(__err);
1202                                        }
1203                                    },
1204                                );
1205                            }
1206                            __Field::m_userData => {
1207                                #[cfg(
1208                                    any(feature = "strict", feature = "ignore_duplicates")
1209                                )]
1210                                if _serde::__private::Option::is_some(&m_userData) {
1211                                    #[cfg(feature = "ignore_duplicates")]
1212                                    {
1213                                        __A::skip_value(&mut __map)?;
1214                                        continue;
1215                                    }
1216                                    #[cfg(feature = "strict")]
1217                                    return _serde::__private::Err(
1218                                        <__A::Error as _serde::de::Error>::duplicate_field(
1219                                            "userData",
1220                                        ),
1221                                    );
1222                                }
1223                                m_userData = _serde::__private::Some(
1224                                    match __A::next_value::<Ulong>(&mut __map) {
1225                                        _serde::__private::Ok(__val) => __val,
1226                                        _serde::__private::Err(__err) => {
1227                                            return _serde::__private::Err(__err);
1228                                        }
1229                                    },
1230                                );
1231                            }
1232                            __Field::m_name => {
1233                                #[cfg(
1234                                    any(feature = "strict", feature = "ignore_duplicates")
1235                                )]
1236                                if _serde::__private::Option::is_some(&m_name) {
1237                                    #[cfg(feature = "ignore_duplicates")]
1238                                    {
1239                                        __A::skip_value(&mut __map)?;
1240                                        continue;
1241                                    }
1242                                    #[cfg(feature = "strict")]
1243                                    return _serde::__private::Err(
1244                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
1245                                    );
1246                                }
1247                                m_name = _serde::__private::Some(
1248                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
1249                                        _serde::__private::Ok(__val) => __val,
1250                                        _serde::__private::Err(__err) => {
1251                                            return _serde::__private::Err(__err);
1252                                        }
1253                                    },
1254                                );
1255                            }
1256                            __Field::m_enable => {
1257                                #[cfg(
1258                                    any(feature = "strict", feature = "ignore_duplicates")
1259                                )]
1260                                if _serde::__private::Option::is_some(&m_enable) {
1261                                    #[cfg(feature = "ignore_duplicates")]
1262                                    {
1263                                        __A::skip_value(&mut __map)?;
1264                                        continue;
1265                                    }
1266                                    #[cfg(feature = "strict")]
1267                                    return _serde::__private::Err(
1268                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
1269                                    );
1270                                }
1271                                m_enable = _serde::__private::Some(
1272                                    match __A::next_value::<bool>(&mut __map) {
1273                                        _serde::__private::Ok(__val) => __val,
1274                                        _serde::__private::Err(__err) => {
1275                                            return _serde::__private::Err(__err);
1276                                        }
1277                                    },
1278                                );
1279                            }
1280                            __Field::m_gains => {
1281                                #[cfg(
1282                                    any(feature = "strict", feature = "ignore_duplicates")
1283                                )]
1284                                if _serde::__private::Option::is_some(&m_gains) {
1285                                    #[cfg(feature = "ignore_duplicates")]
1286                                    {
1287                                        __A::skip_value(&mut __map)?;
1288                                        continue;
1289                                    }
1290                                    #[cfg(feature = "strict")]
1291                                    return _serde::__private::Err(
1292                                        <__A::Error as _serde::de::Error>::duplicate_field("gains"),
1293                                    );
1294                                }
1295                                m_gains = _serde::__private::Some(
1296                                    match __A::next_value::<hkbFootIkGains>(&mut __map) {
1297                                        _serde::__private::Ok(__val) => __val,
1298                                        _serde::__private::Err(__err) => {
1299                                            return _serde::__private::Err(__err);
1300                                        }
1301                                    },
1302                                );
1303                            }
1304                            __Field::m_legs => {
1305                                #[cfg(
1306                                    any(feature = "strict", feature = "ignore_duplicates")
1307                                )]
1308                                if _serde::__private::Option::is_some(&m_legs) {
1309                                    #[cfg(feature = "ignore_duplicates")]
1310                                    {
1311                                        __A::skip_value(&mut __map)?;
1312                                        continue;
1313                                    }
1314                                    #[cfg(feature = "strict")]
1315                                    return _serde::__private::Err(
1316                                        <__A::Error as _serde::de::Error>::duplicate_field("legs"),
1317                                    );
1318                                }
1319                                m_legs = _serde::__private::Some(
1320                                    match __A::next_value::<
1321                                        Vec<hkbFootIkModifierLeg>,
1322                                    >(&mut __map) {
1323                                        _serde::__private::Ok(__val) => __val,
1324                                        _serde::__private::Err(__err) => {
1325                                            return _serde::__private::Err(__err);
1326                                        }
1327                                    },
1328                                );
1329                            }
1330                            __Field::m_raycastDistanceUp => {
1331                                #[cfg(
1332                                    any(feature = "strict", feature = "ignore_duplicates")
1333                                )]
1334                                if _serde::__private::Option::is_some(
1335                                    &m_raycastDistanceUp,
1336                                ) {
1337                                    #[cfg(feature = "ignore_duplicates")]
1338                                    {
1339                                        __A::skip_value(&mut __map)?;
1340                                        continue;
1341                                    }
1342                                    #[cfg(feature = "strict")]
1343                                    return _serde::__private::Err(
1344                                        <__A::Error as _serde::de::Error>::duplicate_field(
1345                                            "raycastDistanceUp",
1346                                        ),
1347                                    );
1348                                }
1349                                m_raycastDistanceUp = _serde::__private::Some(
1350                                    match __A::next_value::<f32>(&mut __map) {
1351                                        _serde::__private::Ok(__val) => __val,
1352                                        _serde::__private::Err(__err) => {
1353                                            return _serde::__private::Err(__err);
1354                                        }
1355                                    },
1356                                );
1357                            }
1358                            __Field::m_raycastDistanceDown => {
1359                                #[cfg(
1360                                    any(feature = "strict", feature = "ignore_duplicates")
1361                                )]
1362                                if _serde::__private::Option::is_some(
1363                                    &m_raycastDistanceDown,
1364                                ) {
1365                                    #[cfg(feature = "ignore_duplicates")]
1366                                    {
1367                                        __A::skip_value(&mut __map)?;
1368                                        continue;
1369                                    }
1370                                    #[cfg(feature = "strict")]
1371                                    return _serde::__private::Err(
1372                                        <__A::Error as _serde::de::Error>::duplicate_field(
1373                                            "raycastDistanceDown",
1374                                        ),
1375                                    );
1376                                }
1377                                m_raycastDistanceDown = _serde::__private::Some(
1378                                    match __A::next_value::<f32>(&mut __map) {
1379                                        _serde::__private::Ok(__val) => __val,
1380                                        _serde::__private::Err(__err) => {
1381                                            return _serde::__private::Err(__err);
1382                                        }
1383                                    },
1384                                );
1385                            }
1386                            __Field::m_originalGroundHeightMS => {
1387                                #[cfg(
1388                                    any(feature = "strict", feature = "ignore_duplicates")
1389                                )]
1390                                if _serde::__private::Option::is_some(
1391                                    &m_originalGroundHeightMS,
1392                                ) {
1393                                    #[cfg(feature = "ignore_duplicates")]
1394                                    {
1395                                        __A::skip_value(&mut __map)?;
1396                                        continue;
1397                                    }
1398                                    #[cfg(feature = "strict")]
1399                                    return _serde::__private::Err(
1400                                        <__A::Error as _serde::de::Error>::duplicate_field(
1401                                            "originalGroundHeightMS",
1402                                        ),
1403                                    );
1404                                }
1405                                m_originalGroundHeightMS = _serde::__private::Some(
1406                                    match __A::next_value::<f32>(&mut __map) {
1407                                        _serde::__private::Ok(__val) => __val,
1408                                        _serde::__private::Err(__err) => {
1409                                            return _serde::__private::Err(__err);
1410                                        }
1411                                    },
1412                                );
1413                            }
1414                            __Field::m_errorOut => {
1415                                #[cfg(
1416                                    any(feature = "strict", feature = "ignore_duplicates")
1417                                )]
1418                                if _serde::__private::Option::is_some(&m_errorOut) {
1419                                    #[cfg(feature = "ignore_duplicates")]
1420                                    {
1421                                        __A::skip_value(&mut __map)?;
1422                                        continue;
1423                                    }
1424                                    #[cfg(feature = "strict")]
1425                                    return _serde::__private::Err(
1426                                        <__A::Error as _serde::de::Error>::duplicate_field(
1427                                            "errorOut",
1428                                        ),
1429                                    );
1430                                }
1431                                m_errorOut = _serde::__private::Some(
1432                                    match __A::next_value::<f32>(&mut __map) {
1433                                        _serde::__private::Ok(__val) => __val,
1434                                        _serde::__private::Err(__err) => {
1435                                            return _serde::__private::Err(__err);
1436                                        }
1437                                    },
1438                                );
1439                            }
1440                            __Field::m_errorOutTranslation => {
1441                                #[cfg(
1442                                    any(feature = "strict", feature = "ignore_duplicates")
1443                                )]
1444                                if _serde::__private::Option::is_some(
1445                                    &m_errorOutTranslation,
1446                                ) {
1447                                    #[cfg(feature = "ignore_duplicates")]
1448                                    {
1449                                        __A::skip_value(&mut __map)?;
1450                                        continue;
1451                                    }
1452                                    #[cfg(feature = "strict")]
1453                                    return _serde::__private::Err(
1454                                        <__A::Error as _serde::de::Error>::duplicate_field(
1455                                            "errorOutTranslation",
1456                                        ),
1457                                    );
1458                                }
1459                                m_errorOutTranslation = _serde::__private::Some(
1460                                    match __A::next_value::<Vector4>(&mut __map) {
1461                                        _serde::__private::Ok(__val) => __val,
1462                                        _serde::__private::Err(__err) => {
1463                                            return _serde::__private::Err(__err);
1464                                        }
1465                                    },
1466                                );
1467                            }
1468                            __Field::m_alignWithGroundRotation => {
1469                                #[cfg(
1470                                    any(feature = "strict", feature = "ignore_duplicates")
1471                                )]
1472                                if _serde::__private::Option::is_some(
1473                                    &m_alignWithGroundRotation,
1474                                ) {
1475                                    #[cfg(feature = "ignore_duplicates")]
1476                                    {
1477                                        __A::skip_value(&mut __map)?;
1478                                        continue;
1479                                    }
1480                                    #[cfg(feature = "strict")]
1481                                    return _serde::__private::Err(
1482                                        <__A::Error as _serde::de::Error>::duplicate_field(
1483                                            "alignWithGroundRotation",
1484                                        ),
1485                                    );
1486                                }
1487                                m_alignWithGroundRotation = _serde::__private::Some(
1488                                    match __A::next_value::<Quaternion>(&mut __map) {
1489                                        _serde::__private::Ok(__val) => __val,
1490                                        _serde::__private::Err(__err) => {
1491                                            return _serde::__private::Err(__err);
1492                                        }
1493                                    },
1494                                );
1495                            }
1496                            __Field::m_verticalOffset => {
1497                                #[cfg(
1498                                    any(feature = "strict", feature = "ignore_duplicates")
1499                                )]
1500                                if _serde::__private::Option::is_some(&m_verticalOffset) {
1501                                    #[cfg(feature = "ignore_duplicates")]
1502                                    {
1503                                        __A::skip_value(&mut __map)?;
1504                                        continue;
1505                                    }
1506                                    #[cfg(feature = "strict")]
1507                                    return _serde::__private::Err(
1508                                        <__A::Error as _serde::de::Error>::duplicate_field(
1509                                            "verticalOffset",
1510                                        ),
1511                                    );
1512                                }
1513                                m_verticalOffset = _serde::__private::Some(
1514                                    match __A::next_value::<f32>(&mut __map) {
1515                                        _serde::__private::Ok(__val) => __val,
1516                                        _serde::__private::Err(__err) => {
1517                                            return _serde::__private::Err(__err);
1518                                        }
1519                                    },
1520                                );
1521                            }
1522                            __Field::m_collisionFilterInfo => {
1523                                #[cfg(
1524                                    any(feature = "strict", feature = "ignore_duplicates")
1525                                )]
1526                                if _serde::__private::Option::is_some(
1527                                    &m_collisionFilterInfo,
1528                                ) {
1529                                    #[cfg(feature = "ignore_duplicates")]
1530                                    {
1531                                        __A::skip_value(&mut __map)?;
1532                                        continue;
1533                                    }
1534                                    #[cfg(feature = "strict")]
1535                                    return _serde::__private::Err(
1536                                        <__A::Error as _serde::de::Error>::duplicate_field(
1537                                            "collisionFilterInfo",
1538                                        ),
1539                                    );
1540                                }
1541                                m_collisionFilterInfo = _serde::__private::Some(
1542                                    match __A::next_value::<u32>(&mut __map) {
1543                                        _serde::__private::Ok(__val) => __val,
1544                                        _serde::__private::Err(__err) => {
1545                                            return _serde::__private::Err(__err);
1546                                        }
1547                                    },
1548                                );
1549                            }
1550                            __Field::m_forwardAlignFraction => {
1551                                #[cfg(
1552                                    any(feature = "strict", feature = "ignore_duplicates")
1553                                )]
1554                                if _serde::__private::Option::is_some(
1555                                    &m_forwardAlignFraction,
1556                                ) {
1557                                    #[cfg(feature = "ignore_duplicates")]
1558                                    {
1559                                        __A::skip_value(&mut __map)?;
1560                                        continue;
1561                                    }
1562                                    #[cfg(feature = "strict")]
1563                                    return _serde::__private::Err(
1564                                        <__A::Error as _serde::de::Error>::duplicate_field(
1565                                            "forwardAlignFraction",
1566                                        ),
1567                                    );
1568                                }
1569                                m_forwardAlignFraction = _serde::__private::Some(
1570                                    match __A::next_value::<f32>(&mut __map) {
1571                                        _serde::__private::Ok(__val) => __val,
1572                                        _serde::__private::Err(__err) => {
1573                                            return _serde::__private::Err(__err);
1574                                        }
1575                                    },
1576                                );
1577                            }
1578                            __Field::m_sidewaysAlignFraction => {
1579                                #[cfg(
1580                                    any(feature = "strict", feature = "ignore_duplicates")
1581                                )]
1582                                if _serde::__private::Option::is_some(
1583                                    &m_sidewaysAlignFraction,
1584                                ) {
1585                                    #[cfg(feature = "ignore_duplicates")]
1586                                    {
1587                                        __A::skip_value(&mut __map)?;
1588                                        continue;
1589                                    }
1590                                    #[cfg(feature = "strict")]
1591                                    return _serde::__private::Err(
1592                                        <__A::Error as _serde::de::Error>::duplicate_field(
1593                                            "sidewaysAlignFraction",
1594                                        ),
1595                                    );
1596                                }
1597                                m_sidewaysAlignFraction = _serde::__private::Some(
1598                                    match __A::next_value::<f32>(&mut __map) {
1599                                        _serde::__private::Ok(__val) => __val,
1600                                        _serde::__private::Err(__err) => {
1601                                            return _serde::__private::Err(__err);
1602                                        }
1603                                    },
1604                                );
1605                            }
1606                            __Field::m_sidewaysSampleWidth => {
1607                                #[cfg(
1608                                    any(feature = "strict", feature = "ignore_duplicates")
1609                                )]
1610                                if _serde::__private::Option::is_some(
1611                                    &m_sidewaysSampleWidth,
1612                                ) {
1613                                    #[cfg(feature = "ignore_duplicates")]
1614                                    {
1615                                        __A::skip_value(&mut __map)?;
1616                                        continue;
1617                                    }
1618                                    #[cfg(feature = "strict")]
1619                                    return _serde::__private::Err(
1620                                        <__A::Error as _serde::de::Error>::duplicate_field(
1621                                            "sidewaysSampleWidth",
1622                                        ),
1623                                    );
1624                                }
1625                                m_sidewaysSampleWidth = _serde::__private::Some(
1626                                    match __A::next_value::<f32>(&mut __map) {
1627                                        _serde::__private::Ok(__val) => __val,
1628                                        _serde::__private::Err(__err) => {
1629                                            return _serde::__private::Err(__err);
1630                                        }
1631                                    },
1632                                );
1633                            }
1634                            __Field::m_useTrackData => {
1635                                #[cfg(
1636                                    any(feature = "strict", feature = "ignore_duplicates")
1637                                )]
1638                                if _serde::__private::Option::is_some(&m_useTrackData) {
1639                                    #[cfg(feature = "ignore_duplicates")]
1640                                    {
1641                                        __A::skip_value(&mut __map)?;
1642                                        continue;
1643                                    }
1644                                    #[cfg(feature = "strict")]
1645                                    return _serde::__private::Err(
1646                                        <__A::Error as _serde::de::Error>::duplicate_field(
1647                                            "useTrackData",
1648                                        ),
1649                                    );
1650                                }
1651                                m_useTrackData = _serde::__private::Some(
1652                                    match __A::next_value::<bool>(&mut __map) {
1653                                        _serde::__private::Ok(__val) => __val,
1654                                        _serde::__private::Err(__err) => {
1655                                            return _serde::__private::Err(__err);
1656                                        }
1657                                    },
1658                                );
1659                            }
1660                            __Field::m_lockFeetWhenPlanted => {
1661                                #[cfg(
1662                                    any(feature = "strict", feature = "ignore_duplicates")
1663                                )]
1664                                if _serde::__private::Option::is_some(
1665                                    &m_lockFeetWhenPlanted,
1666                                ) {
1667                                    #[cfg(feature = "ignore_duplicates")]
1668                                    {
1669                                        __A::skip_value(&mut __map)?;
1670                                        continue;
1671                                    }
1672                                    #[cfg(feature = "strict")]
1673                                    return _serde::__private::Err(
1674                                        <__A::Error as _serde::de::Error>::duplicate_field(
1675                                            "lockFeetWhenPlanted",
1676                                        ),
1677                                    );
1678                                }
1679                                m_lockFeetWhenPlanted = _serde::__private::Some(
1680                                    match __A::next_value::<bool>(&mut __map) {
1681                                        _serde::__private::Ok(__val) => __val,
1682                                        _serde::__private::Err(__err) => {
1683                                            return _serde::__private::Err(__err);
1684                                        }
1685                                    },
1686                                );
1687                            }
1688                            __Field::m_useCharacterUpVector => {
1689                                #[cfg(
1690                                    any(feature = "strict", feature = "ignore_duplicates")
1691                                )]
1692                                if _serde::__private::Option::is_some(
1693                                    &m_useCharacterUpVector,
1694                                ) {
1695                                    #[cfg(feature = "ignore_duplicates")]
1696                                    {
1697                                        __A::skip_value(&mut __map)?;
1698                                        continue;
1699                                    }
1700                                    #[cfg(feature = "strict")]
1701                                    return _serde::__private::Err(
1702                                        <__A::Error as _serde::de::Error>::duplicate_field(
1703                                            "useCharacterUpVector",
1704                                        ),
1705                                    );
1706                                }
1707                                m_useCharacterUpVector = _serde::__private::Some(
1708                                    match __A::next_value::<bool>(&mut __map) {
1709                                        _serde::__private::Ok(__val) => __val,
1710                                        _serde::__private::Err(__err) => {
1711                                            return _serde::__private::Err(__err);
1712                                        }
1713                                    },
1714                                );
1715                            }
1716                            __Field::m_alignMode => {
1717                                #[cfg(
1718                                    any(feature = "strict", feature = "ignore_duplicates")
1719                                )]
1720                                if _serde::__private::Option::is_some(&m_alignMode) {
1721                                    #[cfg(feature = "ignore_duplicates")]
1722                                    {
1723                                        __A::skip_value(&mut __map)?;
1724                                        continue;
1725                                    }
1726                                    #[cfg(feature = "strict")]
1727                                    return _serde::__private::Err(
1728                                        <__A::Error as _serde::de::Error>::duplicate_field(
1729                                            "alignMode",
1730                                        ),
1731                                    );
1732                                }
1733                                m_alignMode = _serde::__private::Some(
1734                                    match __A::next_value::<AlignMode>(&mut __map) {
1735                                        _serde::__private::Ok(__val) => __val,
1736                                        _serde::__private::Err(__err) => {
1737                                            return _serde::__private::Err(__err);
1738                                        }
1739                                    },
1740                                );
1741                            }
1742                            _ => __A::skip_value(&mut __map)?,
1743                        }
1744                    }
1745                    let m_variableBindingSet = match m_variableBindingSet {
1746                        _serde::__private::Some(__field) => __field,
1747                        _serde::__private::None => {
1748                            #[cfg(feature = "strict")]
1749                            return _serde::__private::Err(
1750                                <__A::Error as _serde::de::Error>::missing_field(
1751                                    "variableBindingSet",
1752                                ),
1753                            );
1754                            #[cfg(not(feature = "strict"))] Default::default()
1755                        }
1756                    };
1757                    let m_userData = match m_userData {
1758                        _serde::__private::Some(__field) => __field,
1759                        _serde::__private::None => {
1760                            #[cfg(feature = "strict")]
1761                            return _serde::__private::Err(
1762                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1763                            );
1764                            #[cfg(not(feature = "strict"))] Default::default()
1765                        }
1766                    };
1767                    let m_name = match m_name {
1768                        _serde::__private::Some(__field) => __field,
1769                        _serde::__private::None => {
1770                            #[cfg(feature = "strict")]
1771                            return _serde::__private::Err(
1772                                <__A::Error as _serde::de::Error>::missing_field("name"),
1773                            );
1774                            #[cfg(not(feature = "strict"))] Default::default()
1775                        }
1776                    };
1777                    let m_enable = match m_enable {
1778                        _serde::__private::Some(__field) => __field,
1779                        _serde::__private::None => {
1780                            #[cfg(feature = "strict")]
1781                            return _serde::__private::Err(
1782                                <__A::Error as _serde::de::Error>::missing_field("enable"),
1783                            );
1784                            #[cfg(not(feature = "strict"))] Default::default()
1785                        }
1786                    };
1787                    let m_gains = match m_gains {
1788                        _serde::__private::Some(__field) => __field,
1789                        _serde::__private::None => {
1790                            #[cfg(feature = "strict")]
1791                            return _serde::__private::Err(
1792                                <__A::Error as _serde::de::Error>::missing_field("gains"),
1793                            );
1794                            #[cfg(not(feature = "strict"))] Default::default()
1795                        }
1796                    };
1797                    let m_legs = match m_legs {
1798                        _serde::__private::Some(__field) => __field,
1799                        _serde::__private::None => {
1800                            #[cfg(feature = "strict")]
1801                            return _serde::__private::Err(
1802                                <__A::Error as _serde::de::Error>::missing_field("legs"),
1803                            );
1804                            #[cfg(not(feature = "strict"))] Default::default()
1805                        }
1806                    };
1807                    let m_raycastDistanceUp = match m_raycastDistanceUp {
1808                        _serde::__private::Some(__field) => __field,
1809                        _serde::__private::None => {
1810                            #[cfg(feature = "strict")]
1811                            return _serde::__private::Err(
1812                                <__A::Error as _serde::de::Error>::missing_field(
1813                                    "raycastDistanceUp",
1814                                ),
1815                            );
1816                            #[cfg(not(feature = "strict"))] Default::default()
1817                        }
1818                    };
1819                    let m_raycastDistanceDown = match m_raycastDistanceDown {
1820                        _serde::__private::Some(__field) => __field,
1821                        _serde::__private::None => {
1822                            #[cfg(feature = "strict")]
1823                            return _serde::__private::Err(
1824                                <__A::Error as _serde::de::Error>::missing_field(
1825                                    "raycastDistanceDown",
1826                                ),
1827                            );
1828                            #[cfg(not(feature = "strict"))] Default::default()
1829                        }
1830                    };
1831                    let m_originalGroundHeightMS = match m_originalGroundHeightMS {
1832                        _serde::__private::Some(__field) => __field,
1833                        _serde::__private::None => {
1834                            #[cfg(feature = "strict")]
1835                            return _serde::__private::Err(
1836                                <__A::Error as _serde::de::Error>::missing_field(
1837                                    "originalGroundHeightMS",
1838                                ),
1839                            );
1840                            #[cfg(not(feature = "strict"))] Default::default()
1841                        }
1842                    };
1843                    let m_errorOut = match m_errorOut {
1844                        _serde::__private::Some(__field) => __field,
1845                        _serde::__private::None => {
1846                            #[cfg(feature = "strict")]
1847                            return _serde::__private::Err(
1848                                <__A::Error as _serde::de::Error>::missing_field("errorOut"),
1849                            );
1850                            #[cfg(not(feature = "strict"))] Default::default()
1851                        }
1852                    };
1853                    let m_errorOutTranslation = match m_errorOutTranslation {
1854                        _serde::__private::Some(__field) => __field,
1855                        _serde::__private::None => {
1856                            #[cfg(feature = "strict")]
1857                            return _serde::__private::Err(
1858                                <__A::Error as _serde::de::Error>::missing_field(
1859                                    "errorOutTranslation",
1860                                ),
1861                            );
1862                            #[cfg(not(feature = "strict"))] Default::default()
1863                        }
1864                    };
1865                    let m_alignWithGroundRotation = match m_alignWithGroundRotation {
1866                        _serde::__private::Some(__field) => __field,
1867                        _serde::__private::None => {
1868                            #[cfg(feature = "strict")]
1869                            return _serde::__private::Err(
1870                                <__A::Error as _serde::de::Error>::missing_field(
1871                                    "alignWithGroundRotation",
1872                                ),
1873                            );
1874                            #[cfg(not(feature = "strict"))] Default::default()
1875                        }
1876                    };
1877                    let m_verticalOffset = match m_verticalOffset {
1878                        _serde::__private::Some(__field) => __field,
1879                        _serde::__private::None => {
1880                            #[cfg(feature = "strict")]
1881                            return _serde::__private::Err(
1882                                <__A::Error as _serde::de::Error>::missing_field(
1883                                    "verticalOffset",
1884                                ),
1885                            );
1886                            #[cfg(not(feature = "strict"))] Default::default()
1887                        }
1888                    };
1889                    let m_collisionFilterInfo = match m_collisionFilterInfo {
1890                        _serde::__private::Some(__field) => __field,
1891                        _serde::__private::None => {
1892                            #[cfg(feature = "strict")]
1893                            return _serde::__private::Err(
1894                                <__A::Error as _serde::de::Error>::missing_field(
1895                                    "collisionFilterInfo",
1896                                ),
1897                            );
1898                            #[cfg(not(feature = "strict"))] Default::default()
1899                        }
1900                    };
1901                    let m_forwardAlignFraction = match m_forwardAlignFraction {
1902                        _serde::__private::Some(__field) => __field,
1903                        _serde::__private::None => {
1904                            #[cfg(feature = "strict")]
1905                            return _serde::__private::Err(
1906                                <__A::Error as _serde::de::Error>::missing_field(
1907                                    "forwardAlignFraction",
1908                                ),
1909                            );
1910                            #[cfg(not(feature = "strict"))] Default::default()
1911                        }
1912                    };
1913                    let m_sidewaysAlignFraction = match m_sidewaysAlignFraction {
1914                        _serde::__private::Some(__field) => __field,
1915                        _serde::__private::None => {
1916                            #[cfg(feature = "strict")]
1917                            return _serde::__private::Err(
1918                                <__A::Error as _serde::de::Error>::missing_field(
1919                                    "sidewaysAlignFraction",
1920                                ),
1921                            );
1922                            #[cfg(not(feature = "strict"))] Default::default()
1923                        }
1924                    };
1925                    let m_sidewaysSampleWidth = match m_sidewaysSampleWidth {
1926                        _serde::__private::Some(__field) => __field,
1927                        _serde::__private::None => {
1928                            #[cfg(feature = "strict")]
1929                            return _serde::__private::Err(
1930                                <__A::Error as _serde::de::Error>::missing_field(
1931                                    "sidewaysSampleWidth",
1932                                ),
1933                            );
1934                            #[cfg(not(feature = "strict"))] Default::default()
1935                        }
1936                    };
1937                    let m_useTrackData = match m_useTrackData {
1938                        _serde::__private::Some(__field) => __field,
1939                        _serde::__private::None => {
1940                            #[cfg(feature = "strict")]
1941                            return _serde::__private::Err(
1942                                <__A::Error as _serde::de::Error>::missing_field(
1943                                    "useTrackData",
1944                                ),
1945                            );
1946                            #[cfg(not(feature = "strict"))] Default::default()
1947                        }
1948                    };
1949                    let m_lockFeetWhenPlanted = match m_lockFeetWhenPlanted {
1950                        _serde::__private::Some(__field) => __field,
1951                        _serde::__private::None => {
1952                            #[cfg(feature = "strict")]
1953                            return _serde::__private::Err(
1954                                <__A::Error as _serde::de::Error>::missing_field(
1955                                    "lockFeetWhenPlanted",
1956                                ),
1957                            );
1958                            #[cfg(not(feature = "strict"))] Default::default()
1959                        }
1960                    };
1961                    let m_useCharacterUpVector = match m_useCharacterUpVector {
1962                        _serde::__private::Some(__field) => __field,
1963                        _serde::__private::None => {
1964                            #[cfg(feature = "strict")]
1965                            return _serde::__private::Err(
1966                                <__A::Error as _serde::de::Error>::missing_field(
1967                                    "useCharacterUpVector",
1968                                ),
1969                            );
1970                            #[cfg(not(feature = "strict"))] Default::default()
1971                        }
1972                    };
1973                    let m_alignMode = match m_alignMode {
1974                        _serde::__private::Some(__field) => __field,
1975                        _serde::__private::None => {
1976                            #[cfg(feature = "strict")]
1977                            return _serde::__private::Err(
1978                                <__A::Error as _serde::de::Error>::missing_field(
1979                                    "alignMode",
1980                                ),
1981                            );
1982                            #[cfg(not(feature = "strict"))] Default::default()
1983                        }
1984                    };
1985                    let __ptr = None;
1986                    let parent = hkBaseObject { __ptr };
1987                    let parent = hkReferencedObject {
1988                        __ptr,
1989                        parent,
1990                        ..Default::default()
1991                    };
1992                    let parent = hkbBindable {
1993                        __ptr,
1994                        parent,
1995                        m_variableBindingSet,
1996                        ..Default::default()
1997                    };
1998                    let parent = hkbNode {
1999                        __ptr,
2000                        parent,
2001                        m_userData,
2002                        m_name,
2003                        ..Default::default()
2004                    };
2005                    let parent = hkbModifier {
2006                        __ptr,
2007                        parent,
2008                        m_enable,
2009                        ..Default::default()
2010                    };
2011                    let __ptr = __A::class_ptr(&mut __map);
2012                    _serde::__private::Ok(hkbFootIkModifier {
2013                        __ptr,
2014                        parent,
2015                        m_gains,
2016                        m_legs,
2017                        m_raycastDistanceUp,
2018                        m_raycastDistanceDown,
2019                        m_originalGroundHeightMS,
2020                        m_errorOut,
2021                        m_errorOutTranslation,
2022                        m_alignWithGroundRotation,
2023                        m_verticalOffset,
2024                        m_collisionFilterInfo,
2025                        m_forwardAlignFraction,
2026                        m_sidewaysAlignFraction,
2027                        m_sidewaysSampleWidth,
2028                        m_useTrackData,
2029                        m_lockFeetWhenPlanted,
2030                        m_useCharacterUpVector,
2031                        m_alignMode,
2032                        ..Default::default()
2033                    })
2034                }
2035            }
2036            const FIELDS: &[&str] = &[
2037                "gains",
2038                "legs",
2039                "raycastDistanceUp",
2040                "raycastDistanceDown",
2041                "originalGroundHeightMS",
2042                "errorOut",
2043                "errorOutTranslation",
2044                "alignWithGroundRotation",
2045                "verticalOffset",
2046                "collisionFilterInfo",
2047                "forwardAlignFraction",
2048                "sidewaysAlignFraction",
2049                "sidewaysSampleWidth",
2050                "useTrackData",
2051                "lockFeetWhenPlanted",
2052                "useCharacterUpVector",
2053                "alignMode",
2054                "internalLegData",
2055                "prevIsFootIkEnabled",
2056                "isSetUp",
2057                "isGroundPositionValid",
2058                "timeStep",
2059            ];
2060            _serde::Deserializer::deserialize_struct(
2061                deserializer,
2062                "hkbFootIkModifier",
2063                FIELDS,
2064                __hkbFootIkModifierVisitor {
2065                    marker: _serde::__private::PhantomData::<hkbFootIkModifier>,
2066                    lifetime: _serde::__private::PhantomData,
2067                },
2068            )
2069        }
2070    }
2071};
2072/// # C++ Info
2073/// - name: `AlignMode`(ctype: `hkEnum<AlignMode, hkInt8>`)
2074#[allow(non_upper_case_globals, non_snake_case)]
2075#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2076#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2077#[derive(
2078    Debug,
2079    Clone,
2080    Default,
2081    PartialEq,
2082    Eq,
2083    PartialOrd,
2084    Ord,
2085    num_derive::ToPrimitive,
2086    num_derive::FromPrimitive,
2087)]
2088pub enum AlignMode {
2089    #[default]
2090    ALIGN_MODE_FORWARD_RIGHT = 0isize,
2091    ALIGN_MODE_FORWARD = 1isize,
2092}
2093const _: () = {
2094    use havok_serde as __serde;
2095    impl __serde::Serialize for AlignMode {
2096        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2097        where
2098            S: __serde::ser::Serializer,
2099        {
2100            let mut __serializer = __serializer.serialize_enum_flags()?;
2101            match self {
2102                Self::ALIGN_MODE_FORWARD_RIGHT => {
2103                    __serializer.serialize_field("ALIGN_MODE_FORWARD_RIGHT", &0u64)
2104                }
2105                Self::ALIGN_MODE_FORWARD => {
2106                    __serializer.serialize_field("ALIGN_MODE_FORWARD", &1u64)
2107                }
2108            }?;
2109            use num_traits::ToPrimitive as _;
2110            let num = self
2111                .to_i8()
2112                .ok_or(S::Error::custom("Failed enum AlignMode to_i8"))?;
2113            __serializer.serialize_bits(&num)?;
2114            __serializer.end()
2115        }
2116    }
2117};
2118#[doc(hidden)]
2119#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2120const _: () = {
2121    #[allow(unused_extern_crates, clippy::useless_attribute)]
2122    extern crate havok_serde as _serde;
2123    #[automatically_derived]
2124    impl<'de> _serde::Deserialize<'de> for AlignMode {
2125        fn deserialize<__D>(
2126            __deserializer: __D,
2127        ) -> _serde::__private::Result<Self, __D::Error>
2128        where
2129            __D: _serde::Deserializer<'de>,
2130        {
2131            #[allow(non_camel_case_types)]
2132            #[doc(hidden)]
2133            enum __Field {
2134                __field0,
2135                __field1,
2136            }
2137            #[doc(hidden)]
2138            struct __FieldVisitor;
2139            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2140                type Value = __Field;
2141                fn expecting(
2142                    &self,
2143                    __formatter: &mut _serde::__private::Formatter,
2144                ) -> _serde::__private::fmt::Result {
2145                    _serde::__private::Formatter::write_str(
2146                        __formatter,
2147                        "variant identifier",
2148                    )
2149                }
2150                fn visit_int8<__E>(
2151                    self,
2152                    __value: i8,
2153                ) -> _serde::__private::Result<Self::Value, __E>
2154                where
2155                    __E: _serde::de::Error,
2156                {
2157                    match __value {
2158                        0i8 => _serde::__private::Ok(__Field::__field0),
2159                        1i8 => _serde::__private::Ok(__Field::__field1),
2160                        _ => {
2161                            _serde::__private::Err(
2162                                _serde::de::Error::invalid_value(
2163                                    _serde::de::Unexpected::Int8(__value),
2164                                    &"value(i8) of variant is one of 0, 1",
2165                                ),
2166                            )
2167                        }
2168                    }
2169                }
2170                fn visit_stringptr<__E>(
2171                    self,
2172                    __value: StringPtr<'de>,
2173                ) -> _serde::__private::Result<Self::Value, __E>
2174                where
2175                    __E: _serde::de::Error,
2176                {
2177                    if let Some(__value) = __value.into_inner() {
2178                        match __value.as_ref() {
2179                            v if v == "0"
2180                                || v.eq_ignore_ascii_case("ALIGN_MODE_FORWARD_RIGHT") => {
2181                                _serde::__private::Ok(__Field::__field0)
2182                            }
2183                            v if v == "1"
2184                                || v.eq_ignore_ascii_case("ALIGN_MODE_FORWARD") => {
2185                                _serde::__private::Ok(__Field::__field1)
2186                            }
2187                            _ => {
2188                                _serde::__private::Err(
2189                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
2190                                )
2191                            }
2192                        }
2193                    } else {
2194                        _serde::__private::Err(
2195                            _serde::de::Error::unknown_variant("None", VARIANTS),
2196                        )
2197                    }
2198                }
2199            }
2200            impl<'de> _serde::Deserialize<'de> for __Field {
2201                #[inline]
2202                fn deserialize<__D>(
2203                    __deserializer: __D,
2204                ) -> _serde::__private::Result<Self, __D::Error>
2205                where
2206                    __D: _serde::Deserializer<'de>,
2207                {
2208                    _serde::Deserializer::deserialize_identifier(
2209                        __deserializer,
2210                        _serde::de::ReadEnumSize::Int8,
2211                        __FieldVisitor,
2212                    )
2213                }
2214            }
2215            #[doc(hidden)]
2216            struct __Visitor<'de> {
2217                marker: _serde::__private::PhantomData<AlignMode>,
2218                lifetime: _serde::__private::PhantomData<&'de ()>,
2219            }
2220            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2221                type Value = AlignMode;
2222                fn expecting(
2223                    &self,
2224                    __formatter: &mut _serde::__private::Formatter,
2225                ) -> _serde::__private::fmt::Result {
2226                    _serde::__private::Formatter::write_str(
2227                        __formatter,
2228                        "enum AlignMode",
2229                    )
2230                }
2231                fn visit_enum<__A>(
2232                    self,
2233                    __data: __A,
2234                ) -> _serde::__private::Result<Self::Value, __A::Error>
2235                where
2236                    __A: _serde::de::EnumAccess<'de>,
2237                {
2238                    match _serde::de::EnumAccess::variant(__data)? {
2239                        (__Field::__field0, __variant) => {
2240                            _serde::de::VariantAccess::unit_variant(__variant)?;
2241                            _serde::__private::Ok(AlignMode::ALIGN_MODE_FORWARD_RIGHT)
2242                        }
2243                        (__Field::__field1, __variant) => {
2244                            _serde::de::VariantAccess::unit_variant(__variant)?;
2245                            _serde::__private::Ok(AlignMode::ALIGN_MODE_FORWARD)
2246                        }
2247                    }
2248                }
2249            }
2250            #[doc(hidden)]
2251            const VARIANTS: &'static [&'static str] = &[
2252                "ALIGN_MODE_FORWARD_RIGHT",
2253                "ALIGN_MODE_FORWARD",
2254            ];
2255            _serde::Deserializer::deserialize_enum(
2256                __deserializer,
2257                "AlignMode",
2258                VARIANTS,
2259                __Visitor {
2260                    marker: _serde::__private::PhantomData::<AlignMode>,
2261                    lifetime: _serde::__private::PhantomData,
2262                },
2263            )
2264        }
2265    }
2266};