havok_classes/generated/
hkbClipGenerator_.rs

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