havok_classes/generated/
hkaFootstepAnalysisInfo_.rs

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