havok_classes/generated/
hkbPoseMatchingGenerator_.rs

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