havok_classes/generated/
hkbClipGeneratorInternalState_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbClipGeneratorInternalState`
5/// - version: `0`
6/// - signature: `0x26ce5bf3`
7/// - size: `112`(x86)/`112`(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 hkbClipGeneratorInternalState {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `extractedMotion`(ctype: `hkQsTransform`)
32    /// - offset: ` 16`(x86)/` 16`(x86_64)
33    /// - type_size: ` 48`(x86)/` 48`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "extractedMotion"))]
35    #[cfg_attr(feature = "serde", serde(rename = "extractedMotion"))]
36    pub m_extractedMotion: QsTransform,
37    /// # C++ Info
38    /// - name: `echos`(ctype: `hkArray<struct hkbClipGeneratorEcho>`)
39    /// - offset: ` 64`(x86)/` 64`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "echos"))]
42    #[cfg_attr(feature = "serde", serde(rename = "echos"))]
43    pub m_echos: Vec<hkbClipGeneratorEcho>,
44    /// # C++ Info
45    /// - name: `localTime`(ctype: `hkReal`)
46    /// - offset: ` 76`(x86)/` 80`(x86_64)
47    /// - type_size: `  4`(x86)/`  4`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "localTime"))]
49    #[cfg_attr(feature = "serde", serde(rename = "localTime"))]
50    pub m_localTime: f32,
51    /// # C++ Info
52    /// - name: `time`(ctype: `hkReal`)
53    /// - offset: ` 80`(x86)/` 84`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "time"))]
56    #[cfg_attr(feature = "serde", serde(rename = "time"))]
57    pub m_time: f32,
58    /// # C++ Info
59    /// - name: `previousUserControlledTimeFraction`(ctype: `hkReal`)
60    /// - offset: ` 84`(x86)/` 88`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(
63        feature = "json_schema",
64        schemars(rename = "previousUserControlledTimeFraction")
65    )]
66    #[cfg_attr(feature = "serde", serde(rename = "previousUserControlledTimeFraction"))]
67    pub m_previousUserControlledTimeFraction: f32,
68    /// # C++ Info
69    /// - name: `bufferSize`(ctype: `hkInt32`)
70    /// - offset: ` 88`(x86)/` 92`(x86_64)
71    /// - type_size: `  4`(x86)/`  4`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "bufferSize"))]
73    #[cfg_attr(feature = "serde", serde(rename = "bufferSize"))]
74    pub m_bufferSize: i32,
75    /// # C++ Info
76    /// - name: `echoBufferSize`(ctype: `hkInt32`)
77    /// - offset: ` 92`(x86)/` 96`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "echoBufferSize"))]
80    #[cfg_attr(feature = "serde", serde(rename = "echoBufferSize"))]
81    pub m_echoBufferSize: i32,
82    /// # C++ Info
83    /// - name: `atEnd`(ctype: `hkBool`)
84    /// - offset: ` 96`(x86)/`100`(x86_64)
85    /// - type_size: `  1`(x86)/`  1`(x86_64)
86    #[cfg_attr(feature = "json_schema", schemars(rename = "atEnd"))]
87    #[cfg_attr(feature = "serde", serde(rename = "atEnd"))]
88    pub m_atEnd: bool,
89    /// # C++ Info
90    /// - name: `ignoreStartTime`(ctype: `hkBool`)
91    /// - offset: ` 97`(x86)/`101`(x86_64)
92    /// - type_size: `  1`(x86)/`  1`(x86_64)
93    #[cfg_attr(feature = "json_schema", schemars(rename = "ignoreStartTime"))]
94    #[cfg_attr(feature = "serde", serde(rename = "ignoreStartTime"))]
95    pub m_ignoreStartTime: bool,
96    /// # C++ Info
97    /// - name: `pingPongBackward`(ctype: `hkBool`)
98    /// - offset: ` 98`(x86)/`102`(x86_64)
99    /// - type_size: `  1`(x86)/`  1`(x86_64)
100    #[cfg_attr(feature = "json_schema", schemars(rename = "pingPongBackward"))]
101    #[cfg_attr(feature = "serde", serde(rename = "pingPongBackward"))]
102    pub m_pingPongBackward: bool,
103}
104const _: () = {
105    use havok_serde as _serde;
106    impl _serde::HavokClass for hkbClipGeneratorInternalState {
107        #[inline]
108        fn name(&self) -> &'static str {
109            "hkbClipGeneratorInternalState"
110        }
111        #[inline]
112        fn signature(&self) -> _serde::__private::Signature {
113            _serde::__private::Signature::new(0x26ce5bf3)
114        }
115        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
116        fn deps_indexes(&self) -> Vec<usize> {
117            let mut v = Vec::new();
118            v.extend(
119                self
120                    .m_echos
121                    .iter()
122                    .flat_map(|class| class.deps_indexes())
123                    .collect::<Vec<usize>>(),
124            );
125            v
126        }
127    }
128    impl _serde::Serialize for hkbClipGeneratorInternalState {
129        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
130        where
131            S: _serde::ser::Serializer,
132        {
133            let class_meta = self
134                .__ptr
135                .map(|name| (name, _serde::__private::Signature::new(0x26ce5bf3)));
136            let mut serializer = __serializer
137                .serialize_struct(
138                    "hkbClipGeneratorInternalState",
139                    class_meta,
140                    (112u64, 112u64),
141                )?;
142            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
143            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
144            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
145            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
146            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
147            serializer.serialize_field("extractedMotion", &self.m_extractedMotion)?;
148            serializer
149                .serialize_array_field(
150                    "echos",
151                    &self.m_echos,
152                    TypeSize::Struct {
153                        size_x86: 16u64,
154                        size_x86_64: 16u64,
155                    },
156                )?;
157            serializer.serialize_field("localTime", &self.m_localTime)?;
158            serializer.serialize_field("time", &self.m_time)?;
159            serializer
160                .serialize_field(
161                    "previousUserControlledTimeFraction",
162                    &self.m_previousUserControlledTimeFraction,
163                )?;
164            serializer.serialize_field("bufferSize", &self.m_bufferSize)?;
165            serializer.serialize_field("echoBufferSize", &self.m_echoBufferSize)?;
166            serializer.serialize_field("atEnd", &self.m_atEnd)?;
167            serializer.serialize_field("ignoreStartTime", &self.m_ignoreStartTime)?;
168            serializer.serialize_field("pingPongBackward", &self.m_pingPongBackward)?;
169            serializer.pad_field([0u8; 13usize].as_slice(), [0u8; 9usize].as_slice())?;
170            serializer.end()
171        }
172    }
173};
174#[doc(hidden)]
175#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
176const _: () = {
177    use havok_serde as _serde;
178    #[automatically_derived]
179    impl<'de> _serde::Deserialize<'de> for hkbClipGeneratorInternalState {
180        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
181        where
182            __D: _serde::Deserializer<'de>,
183        {
184            #[allow(non_camel_case_types)]
185            enum __Field {
186                m_extractedMotion,
187                m_echos,
188                m_localTime,
189                m_time,
190                m_previousUserControlledTimeFraction,
191                m_bufferSize,
192                m_echoBufferSize,
193                m_atEnd,
194                m_ignoreStartTime,
195                m_pingPongBackward,
196                __ignore,
197            }
198            struct __FieldVisitor;
199            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
200                type Value = __Field;
201                fn expecting(
202                    &self,
203                    __formatter: &mut core::fmt::Formatter,
204                ) -> core::fmt::Result {
205                    core::fmt::Formatter::write_str(__formatter, "field identifier")
206                }
207                /// Intended for use in XML.
208                #[allow(clippy::match_single_binding)]
209                #[allow(clippy::reversed_empty_ranges)]
210                #[allow(clippy::single_match)]
211                fn visit_key<__E>(
212                    self,
213                    __value: &str,
214                ) -> core::result::Result<Self::Value, __E>
215                where
216                    __E: _serde::de::Error,
217                {
218                    match __value {
219                        "extractedMotion" => Ok(__Field::m_extractedMotion),
220                        "echos" => Ok(__Field::m_echos),
221                        "localTime" => Ok(__Field::m_localTime),
222                        "time" => Ok(__Field::m_time),
223                        "previousUserControlledTimeFraction" => {
224                            Ok(__Field::m_previousUserControlledTimeFraction)
225                        }
226                        "bufferSize" => Ok(__Field::m_bufferSize),
227                        "echoBufferSize" => Ok(__Field::m_echoBufferSize),
228                        "atEnd" => Ok(__Field::m_atEnd),
229                        "ignoreStartTime" => Ok(__Field::m_ignoreStartTime),
230                        "pingPongBackward" => Ok(__Field::m_pingPongBackward),
231                        _ => Ok(__Field::__ignore),
232                    }
233                }
234            }
235            impl<'de> _serde::Deserialize<'de> for __Field {
236                #[inline]
237                fn deserialize<__D>(
238                    __deserializer: __D,
239                ) -> core::result::Result<Self, __D::Error>
240                where
241                    __D: _serde::Deserializer<'de>,
242                {
243                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
244                }
245            }
246            struct __hkbClipGeneratorInternalStateVisitor<'de> {
247                marker: _serde::__private::PhantomData<hkbClipGeneratorInternalState>,
248                lifetime: _serde::__private::PhantomData<&'de ()>,
249            }
250            #[allow(clippy::match_single_binding)]
251            #[allow(clippy::reversed_empty_ranges)]
252            #[allow(clippy::single_match)]
253            impl<'de> _serde::de::Visitor<'de>
254            for __hkbClipGeneratorInternalStateVisitor<'de> {
255                type Value = hkbClipGeneratorInternalState;
256                fn expecting(
257                    &self,
258                    __formatter: &mut core::fmt::Formatter,
259                ) -> core::fmt::Result {
260                    core::fmt::Formatter::write_str(
261                        __formatter,
262                        "struct hkbClipGeneratorInternalState",
263                    )
264                }
265                fn visit_struct_for_bytes<__A>(
266                    self,
267                    mut __map: __A,
268                ) -> _serde::__private::Result<Self::Value, __A::Error>
269                where
270                    __A: _serde::de::MapAccess<'de>,
271                {
272                    let __ptr = __A::class_ptr(&mut __map);
273                    let parent = __A::parent_value(&mut __map)?;
274                    let mut m_extractedMotion: _serde::__private::Option<QsTransform> = _serde::__private::None;
275                    let mut m_echos: _serde::__private::Option<
276                        Vec<hkbClipGeneratorEcho>,
277                    > = _serde::__private::None;
278                    let mut m_localTime: _serde::__private::Option<f32> = _serde::__private::None;
279                    let mut m_time: _serde::__private::Option<f32> = _serde::__private::None;
280                    let mut m_previousUserControlledTimeFraction: _serde::__private::Option<
281                        f32,
282                    > = _serde::__private::None;
283                    let mut m_bufferSize: _serde::__private::Option<i32> = _serde::__private::None;
284                    let mut m_echoBufferSize: _serde::__private::Option<i32> = _serde::__private::None;
285                    let mut m_atEnd: _serde::__private::Option<bool> = _serde::__private::None;
286                    let mut m_ignoreStartTime: _serde::__private::Option<bool> = _serde::__private::None;
287                    let mut m_pingPongBackward: _serde::__private::Option<bool> = _serde::__private::None;
288                    for i in 0..10usize {
289                        match i {
290                            0usize => {
291                                if _serde::__private::Option::is_some(&m_extractedMotion) {
292                                    return _serde::__private::Err(
293                                        <__A::Error as _serde::de::Error>::duplicate_field(
294                                            "extractedMotion",
295                                        ),
296                                    );
297                                }
298                                __A::pad(&mut __map, 8usize, 0usize)?;
299                                m_extractedMotion = _serde::__private::Some(
300                                    match __A::next_value::<QsTransform>(&mut __map) {
301                                        _serde::__private::Ok(__val) => __val,
302                                        _serde::__private::Err(__err) => {
303                                            return _serde::__private::Err(__err);
304                                        }
305                                    },
306                                );
307                            }
308                            1usize => {
309                                if _serde::__private::Option::is_some(&m_echos) {
310                                    return _serde::__private::Err(
311                                        <__A::Error as _serde::de::Error>::duplicate_field("echos"),
312                                    );
313                                }
314                                m_echos = _serde::__private::Some(
315                                    match __A::next_value::<
316                                        Vec<hkbClipGeneratorEcho>,
317                                    >(&mut __map) {
318                                        _serde::__private::Ok(__val) => __val,
319                                        _serde::__private::Err(__err) => {
320                                            return _serde::__private::Err(__err);
321                                        }
322                                    },
323                                );
324                            }
325                            2usize => {
326                                if _serde::__private::Option::is_some(&m_localTime) {
327                                    return _serde::__private::Err(
328                                        <__A::Error as _serde::de::Error>::duplicate_field(
329                                            "localTime",
330                                        ),
331                                    );
332                                }
333                                m_localTime = _serde::__private::Some(
334                                    match __A::next_value::<f32>(&mut __map) {
335                                        _serde::__private::Ok(__val) => __val,
336                                        _serde::__private::Err(__err) => {
337                                            return _serde::__private::Err(__err);
338                                        }
339                                    },
340                                );
341                            }
342                            3usize => {
343                                if _serde::__private::Option::is_some(&m_time) {
344                                    return _serde::__private::Err(
345                                        <__A::Error as _serde::de::Error>::duplicate_field("time"),
346                                    );
347                                }
348                                m_time = _serde::__private::Some(
349                                    match __A::next_value::<f32>(&mut __map) {
350                                        _serde::__private::Ok(__val) => __val,
351                                        _serde::__private::Err(__err) => {
352                                            return _serde::__private::Err(__err);
353                                        }
354                                    },
355                                );
356                            }
357                            4usize => {
358                                if _serde::__private::Option::is_some(
359                                    &m_previousUserControlledTimeFraction,
360                                ) {
361                                    return _serde::__private::Err(
362                                        <__A::Error as _serde::de::Error>::duplicate_field(
363                                            "previousUserControlledTimeFraction",
364                                        ),
365                                    );
366                                }
367                                m_previousUserControlledTimeFraction = _serde::__private::Some(
368                                    match __A::next_value::<f32>(&mut __map) {
369                                        _serde::__private::Ok(__val) => __val,
370                                        _serde::__private::Err(__err) => {
371                                            return _serde::__private::Err(__err);
372                                        }
373                                    },
374                                );
375                            }
376                            5usize => {
377                                if _serde::__private::Option::is_some(&m_bufferSize) {
378                                    return _serde::__private::Err(
379                                        <__A::Error as _serde::de::Error>::duplicate_field(
380                                            "bufferSize",
381                                        ),
382                                    );
383                                }
384                                m_bufferSize = _serde::__private::Some(
385                                    match __A::next_value::<i32>(&mut __map) {
386                                        _serde::__private::Ok(__val) => __val,
387                                        _serde::__private::Err(__err) => {
388                                            return _serde::__private::Err(__err);
389                                        }
390                                    },
391                                );
392                            }
393                            6usize => {
394                                if _serde::__private::Option::is_some(&m_echoBufferSize) {
395                                    return _serde::__private::Err(
396                                        <__A::Error as _serde::de::Error>::duplicate_field(
397                                            "echoBufferSize",
398                                        ),
399                                    );
400                                }
401                                m_echoBufferSize = _serde::__private::Some(
402                                    match __A::next_value::<i32>(&mut __map) {
403                                        _serde::__private::Ok(__val) => __val,
404                                        _serde::__private::Err(__err) => {
405                                            return _serde::__private::Err(__err);
406                                        }
407                                    },
408                                );
409                            }
410                            7usize => {
411                                if _serde::__private::Option::is_some(&m_atEnd) {
412                                    return _serde::__private::Err(
413                                        <__A::Error as _serde::de::Error>::duplicate_field("atEnd"),
414                                    );
415                                }
416                                m_atEnd = _serde::__private::Some(
417                                    match __A::next_value::<bool>(&mut __map) {
418                                        _serde::__private::Ok(__val) => __val,
419                                        _serde::__private::Err(__err) => {
420                                            return _serde::__private::Err(__err);
421                                        }
422                                    },
423                                );
424                            }
425                            8usize => {
426                                if _serde::__private::Option::is_some(&m_ignoreStartTime) {
427                                    return _serde::__private::Err(
428                                        <__A::Error as _serde::de::Error>::duplicate_field(
429                                            "ignoreStartTime",
430                                        ),
431                                    );
432                                }
433                                m_ignoreStartTime = _serde::__private::Some(
434                                    match __A::next_value::<bool>(&mut __map) {
435                                        _serde::__private::Ok(__val) => __val,
436                                        _serde::__private::Err(__err) => {
437                                            return _serde::__private::Err(__err);
438                                        }
439                                    },
440                                );
441                            }
442                            9usize => {
443                                if _serde::__private::Option::is_some(&m_pingPongBackward) {
444                                    return _serde::__private::Err(
445                                        <__A::Error as _serde::de::Error>::duplicate_field(
446                                            "pingPongBackward",
447                                        ),
448                                    );
449                                }
450                                m_pingPongBackward = _serde::__private::Some(
451                                    match __A::next_value::<bool>(&mut __map) {
452                                        _serde::__private::Ok(__val) => __val,
453                                        _serde::__private::Err(__err) => {
454                                            return _serde::__private::Err(__err);
455                                        }
456                                    },
457                                );
458                            }
459                            _ => {}
460                        }
461                    }
462                    __A::pad(&mut __map, 13usize, 9usize)?;
463                    let m_extractedMotion = match m_extractedMotion {
464                        _serde::__private::Some(__field) => __field,
465                        _serde::__private::None => {
466                            return _serde::__private::Err(
467                                <__A::Error as _serde::de::Error>::missing_field(
468                                    "extractedMotion",
469                                ),
470                            );
471                        }
472                    };
473                    let m_echos = match m_echos {
474                        _serde::__private::Some(__field) => __field,
475                        _serde::__private::None => {
476                            return _serde::__private::Err(
477                                <__A::Error as _serde::de::Error>::missing_field("echos"),
478                            );
479                        }
480                    };
481                    let m_localTime = match m_localTime {
482                        _serde::__private::Some(__field) => __field,
483                        _serde::__private::None => {
484                            return _serde::__private::Err(
485                                <__A::Error as _serde::de::Error>::missing_field(
486                                    "localTime",
487                                ),
488                            );
489                        }
490                    };
491                    let m_time = match m_time {
492                        _serde::__private::Some(__field) => __field,
493                        _serde::__private::None => {
494                            return _serde::__private::Err(
495                                <__A::Error as _serde::de::Error>::missing_field("time"),
496                            );
497                        }
498                    };
499                    let m_previousUserControlledTimeFraction = match m_previousUserControlledTimeFraction {
500                        _serde::__private::Some(__field) => __field,
501                        _serde::__private::None => {
502                            return _serde::__private::Err(
503                                <__A::Error as _serde::de::Error>::missing_field(
504                                    "previousUserControlledTimeFraction",
505                                ),
506                            );
507                        }
508                    };
509                    let m_bufferSize = match m_bufferSize {
510                        _serde::__private::Some(__field) => __field,
511                        _serde::__private::None => {
512                            return _serde::__private::Err(
513                                <__A::Error as _serde::de::Error>::missing_field(
514                                    "bufferSize",
515                                ),
516                            );
517                        }
518                    };
519                    let m_echoBufferSize = match m_echoBufferSize {
520                        _serde::__private::Some(__field) => __field,
521                        _serde::__private::None => {
522                            return _serde::__private::Err(
523                                <__A::Error as _serde::de::Error>::missing_field(
524                                    "echoBufferSize",
525                                ),
526                            );
527                        }
528                    };
529                    let m_atEnd = match m_atEnd {
530                        _serde::__private::Some(__field) => __field,
531                        _serde::__private::None => {
532                            return _serde::__private::Err(
533                                <__A::Error as _serde::de::Error>::missing_field("atEnd"),
534                            );
535                        }
536                    };
537                    let m_ignoreStartTime = match m_ignoreStartTime {
538                        _serde::__private::Some(__field) => __field,
539                        _serde::__private::None => {
540                            return _serde::__private::Err(
541                                <__A::Error as _serde::de::Error>::missing_field(
542                                    "ignoreStartTime",
543                                ),
544                            );
545                        }
546                    };
547                    let m_pingPongBackward = match m_pingPongBackward {
548                        _serde::__private::Some(__field) => __field,
549                        _serde::__private::None => {
550                            return _serde::__private::Err(
551                                <__A::Error as _serde::de::Error>::missing_field(
552                                    "pingPongBackward",
553                                ),
554                            );
555                        }
556                    };
557                    _serde::__private::Ok(hkbClipGeneratorInternalState {
558                        __ptr,
559                        parent,
560                        m_extractedMotion,
561                        m_echos,
562                        m_localTime,
563                        m_time,
564                        m_previousUserControlledTimeFraction,
565                        m_bufferSize,
566                        m_echoBufferSize,
567                        m_atEnd,
568                        m_ignoreStartTime,
569                        m_pingPongBackward,
570                    })
571                }
572                #[allow(clippy::manual_unwrap_or_default)]
573                fn visit_struct<__A>(
574                    self,
575                    mut __map: __A,
576                ) -> _serde::__private::Result<Self::Value, __A::Error>
577                where
578                    __A: _serde::de::MapAccess<'de>,
579                {
580                    let mut m_extractedMotion: _serde::__private::Option<QsTransform> = _serde::__private::None;
581                    let mut m_echos: _serde::__private::Option<
582                        Vec<hkbClipGeneratorEcho>,
583                    > = _serde::__private::None;
584                    let mut m_localTime: _serde::__private::Option<f32> = _serde::__private::None;
585                    let mut m_time: _serde::__private::Option<f32> = _serde::__private::None;
586                    let mut m_previousUserControlledTimeFraction: _serde::__private::Option<
587                        f32,
588                    > = _serde::__private::None;
589                    let mut m_bufferSize: _serde::__private::Option<i32> = _serde::__private::None;
590                    let mut m_echoBufferSize: _serde::__private::Option<i32> = _serde::__private::None;
591                    let mut m_atEnd: _serde::__private::Option<bool> = _serde::__private::None;
592                    let mut m_ignoreStartTime: _serde::__private::Option<bool> = _serde::__private::None;
593                    let mut m_pingPongBackward: _serde::__private::Option<bool> = _serde::__private::None;
594                    while let _serde::__private::Some(__key) = {
595                        __A::next_key::<__Field>(&mut __map)?
596                    } {
597                        match __key {
598                            __Field::m_extractedMotion => {
599                                #[cfg(
600                                    any(feature = "strict", feature = "ignore_duplicates")
601                                )]
602                                if _serde::__private::Option::is_some(&m_extractedMotion) {
603                                    #[cfg(feature = "ignore_duplicates")]
604                                    {
605                                        __A::skip_value(&mut __map)?;
606                                        continue;
607                                    }
608                                    #[cfg(feature = "strict")]
609                                    return _serde::__private::Err(
610                                        <__A::Error as _serde::de::Error>::duplicate_field(
611                                            "extractedMotion",
612                                        ),
613                                    );
614                                }
615                                m_extractedMotion = _serde::__private::Some(
616                                    match __A::next_value::<QsTransform>(&mut __map) {
617                                        _serde::__private::Ok(__val) => __val,
618                                        _serde::__private::Err(__err) => {
619                                            return _serde::__private::Err(__err);
620                                        }
621                                    },
622                                );
623                            }
624                            __Field::m_echos => {
625                                #[cfg(
626                                    any(feature = "strict", feature = "ignore_duplicates")
627                                )]
628                                if _serde::__private::Option::is_some(&m_echos) {
629                                    #[cfg(feature = "ignore_duplicates")]
630                                    {
631                                        __A::skip_value(&mut __map)?;
632                                        continue;
633                                    }
634                                    #[cfg(feature = "strict")]
635                                    return _serde::__private::Err(
636                                        <__A::Error as _serde::de::Error>::duplicate_field("echos"),
637                                    );
638                                }
639                                m_echos = _serde::__private::Some(
640                                    match __A::next_value::<
641                                        Vec<hkbClipGeneratorEcho>,
642                                    >(&mut __map) {
643                                        _serde::__private::Ok(__val) => __val,
644                                        _serde::__private::Err(__err) => {
645                                            return _serde::__private::Err(__err);
646                                        }
647                                    },
648                                );
649                            }
650                            __Field::m_localTime => {
651                                #[cfg(
652                                    any(feature = "strict", feature = "ignore_duplicates")
653                                )]
654                                if _serde::__private::Option::is_some(&m_localTime) {
655                                    #[cfg(feature = "ignore_duplicates")]
656                                    {
657                                        __A::skip_value(&mut __map)?;
658                                        continue;
659                                    }
660                                    #[cfg(feature = "strict")]
661                                    return _serde::__private::Err(
662                                        <__A::Error as _serde::de::Error>::duplicate_field(
663                                            "localTime",
664                                        ),
665                                    );
666                                }
667                                m_localTime = _serde::__private::Some(
668                                    match __A::next_value::<f32>(&mut __map) {
669                                        _serde::__private::Ok(__val) => __val,
670                                        _serde::__private::Err(__err) => {
671                                            return _serde::__private::Err(__err);
672                                        }
673                                    },
674                                );
675                            }
676                            __Field::m_time => {
677                                #[cfg(
678                                    any(feature = "strict", feature = "ignore_duplicates")
679                                )]
680                                if _serde::__private::Option::is_some(&m_time) {
681                                    #[cfg(feature = "ignore_duplicates")]
682                                    {
683                                        __A::skip_value(&mut __map)?;
684                                        continue;
685                                    }
686                                    #[cfg(feature = "strict")]
687                                    return _serde::__private::Err(
688                                        <__A::Error as _serde::de::Error>::duplicate_field("time"),
689                                    );
690                                }
691                                m_time = _serde::__private::Some(
692                                    match __A::next_value::<f32>(&mut __map) {
693                                        _serde::__private::Ok(__val) => __val,
694                                        _serde::__private::Err(__err) => {
695                                            return _serde::__private::Err(__err);
696                                        }
697                                    },
698                                );
699                            }
700                            __Field::m_previousUserControlledTimeFraction => {
701                                #[cfg(
702                                    any(feature = "strict", feature = "ignore_duplicates")
703                                )]
704                                if _serde::__private::Option::is_some(
705                                    &m_previousUserControlledTimeFraction,
706                                ) {
707                                    #[cfg(feature = "ignore_duplicates")]
708                                    {
709                                        __A::skip_value(&mut __map)?;
710                                        continue;
711                                    }
712                                    #[cfg(feature = "strict")]
713                                    return _serde::__private::Err(
714                                        <__A::Error as _serde::de::Error>::duplicate_field(
715                                            "previousUserControlledTimeFraction",
716                                        ),
717                                    );
718                                }
719                                m_previousUserControlledTimeFraction = _serde::__private::Some(
720                                    match __A::next_value::<f32>(&mut __map) {
721                                        _serde::__private::Ok(__val) => __val,
722                                        _serde::__private::Err(__err) => {
723                                            return _serde::__private::Err(__err);
724                                        }
725                                    },
726                                );
727                            }
728                            __Field::m_bufferSize => {
729                                #[cfg(
730                                    any(feature = "strict", feature = "ignore_duplicates")
731                                )]
732                                if _serde::__private::Option::is_some(&m_bufferSize) {
733                                    #[cfg(feature = "ignore_duplicates")]
734                                    {
735                                        __A::skip_value(&mut __map)?;
736                                        continue;
737                                    }
738                                    #[cfg(feature = "strict")]
739                                    return _serde::__private::Err(
740                                        <__A::Error as _serde::de::Error>::duplicate_field(
741                                            "bufferSize",
742                                        ),
743                                    );
744                                }
745                                m_bufferSize = _serde::__private::Some(
746                                    match __A::next_value::<i32>(&mut __map) {
747                                        _serde::__private::Ok(__val) => __val,
748                                        _serde::__private::Err(__err) => {
749                                            return _serde::__private::Err(__err);
750                                        }
751                                    },
752                                );
753                            }
754                            __Field::m_echoBufferSize => {
755                                #[cfg(
756                                    any(feature = "strict", feature = "ignore_duplicates")
757                                )]
758                                if _serde::__private::Option::is_some(&m_echoBufferSize) {
759                                    #[cfg(feature = "ignore_duplicates")]
760                                    {
761                                        __A::skip_value(&mut __map)?;
762                                        continue;
763                                    }
764                                    #[cfg(feature = "strict")]
765                                    return _serde::__private::Err(
766                                        <__A::Error as _serde::de::Error>::duplicate_field(
767                                            "echoBufferSize",
768                                        ),
769                                    );
770                                }
771                                m_echoBufferSize = _serde::__private::Some(
772                                    match __A::next_value::<i32>(&mut __map) {
773                                        _serde::__private::Ok(__val) => __val,
774                                        _serde::__private::Err(__err) => {
775                                            return _serde::__private::Err(__err);
776                                        }
777                                    },
778                                );
779                            }
780                            __Field::m_atEnd => {
781                                #[cfg(
782                                    any(feature = "strict", feature = "ignore_duplicates")
783                                )]
784                                if _serde::__private::Option::is_some(&m_atEnd) {
785                                    #[cfg(feature = "ignore_duplicates")]
786                                    {
787                                        __A::skip_value(&mut __map)?;
788                                        continue;
789                                    }
790                                    #[cfg(feature = "strict")]
791                                    return _serde::__private::Err(
792                                        <__A::Error as _serde::de::Error>::duplicate_field("atEnd"),
793                                    );
794                                }
795                                m_atEnd = _serde::__private::Some(
796                                    match __A::next_value::<bool>(&mut __map) {
797                                        _serde::__private::Ok(__val) => __val,
798                                        _serde::__private::Err(__err) => {
799                                            return _serde::__private::Err(__err);
800                                        }
801                                    },
802                                );
803                            }
804                            __Field::m_ignoreStartTime => {
805                                #[cfg(
806                                    any(feature = "strict", feature = "ignore_duplicates")
807                                )]
808                                if _serde::__private::Option::is_some(&m_ignoreStartTime) {
809                                    #[cfg(feature = "ignore_duplicates")]
810                                    {
811                                        __A::skip_value(&mut __map)?;
812                                        continue;
813                                    }
814                                    #[cfg(feature = "strict")]
815                                    return _serde::__private::Err(
816                                        <__A::Error as _serde::de::Error>::duplicate_field(
817                                            "ignoreStartTime",
818                                        ),
819                                    );
820                                }
821                                m_ignoreStartTime = _serde::__private::Some(
822                                    match __A::next_value::<bool>(&mut __map) {
823                                        _serde::__private::Ok(__val) => __val,
824                                        _serde::__private::Err(__err) => {
825                                            return _serde::__private::Err(__err);
826                                        }
827                                    },
828                                );
829                            }
830                            __Field::m_pingPongBackward => {
831                                #[cfg(
832                                    any(feature = "strict", feature = "ignore_duplicates")
833                                )]
834                                if _serde::__private::Option::is_some(&m_pingPongBackward) {
835                                    #[cfg(feature = "ignore_duplicates")]
836                                    {
837                                        __A::skip_value(&mut __map)?;
838                                        continue;
839                                    }
840                                    #[cfg(feature = "strict")]
841                                    return _serde::__private::Err(
842                                        <__A::Error as _serde::de::Error>::duplicate_field(
843                                            "pingPongBackward",
844                                        ),
845                                    );
846                                }
847                                m_pingPongBackward = _serde::__private::Some(
848                                    match __A::next_value::<bool>(&mut __map) {
849                                        _serde::__private::Ok(__val) => __val,
850                                        _serde::__private::Err(__err) => {
851                                            return _serde::__private::Err(__err);
852                                        }
853                                    },
854                                );
855                            }
856                            _ => __A::skip_value(&mut __map)?,
857                        }
858                    }
859                    let m_extractedMotion = match m_extractedMotion {
860                        _serde::__private::Some(__field) => __field,
861                        _serde::__private::None => {
862                            #[cfg(feature = "strict")]
863                            return _serde::__private::Err(
864                                <__A::Error as _serde::de::Error>::missing_field(
865                                    "extractedMotion",
866                                ),
867                            );
868                            #[cfg(not(feature = "strict"))] Default::default()
869                        }
870                    };
871                    let m_echos = match m_echos {
872                        _serde::__private::Some(__field) => __field,
873                        _serde::__private::None => {
874                            #[cfg(feature = "strict")]
875                            return _serde::__private::Err(
876                                <__A::Error as _serde::de::Error>::missing_field("echos"),
877                            );
878                            #[cfg(not(feature = "strict"))] Default::default()
879                        }
880                    };
881                    let m_localTime = match m_localTime {
882                        _serde::__private::Some(__field) => __field,
883                        _serde::__private::None => {
884                            #[cfg(feature = "strict")]
885                            return _serde::__private::Err(
886                                <__A::Error as _serde::de::Error>::missing_field(
887                                    "localTime",
888                                ),
889                            );
890                            #[cfg(not(feature = "strict"))] Default::default()
891                        }
892                    };
893                    let m_time = match m_time {
894                        _serde::__private::Some(__field) => __field,
895                        _serde::__private::None => {
896                            #[cfg(feature = "strict")]
897                            return _serde::__private::Err(
898                                <__A::Error as _serde::de::Error>::missing_field("time"),
899                            );
900                            #[cfg(not(feature = "strict"))] Default::default()
901                        }
902                    };
903                    let m_previousUserControlledTimeFraction = match m_previousUserControlledTimeFraction {
904                        _serde::__private::Some(__field) => __field,
905                        _serde::__private::None => {
906                            #[cfg(feature = "strict")]
907                            return _serde::__private::Err(
908                                <__A::Error as _serde::de::Error>::missing_field(
909                                    "previousUserControlledTimeFraction",
910                                ),
911                            );
912                            #[cfg(not(feature = "strict"))] Default::default()
913                        }
914                    };
915                    let m_bufferSize = match m_bufferSize {
916                        _serde::__private::Some(__field) => __field,
917                        _serde::__private::None => {
918                            #[cfg(feature = "strict")]
919                            return _serde::__private::Err(
920                                <__A::Error as _serde::de::Error>::missing_field(
921                                    "bufferSize",
922                                ),
923                            );
924                            #[cfg(not(feature = "strict"))] Default::default()
925                        }
926                    };
927                    let m_echoBufferSize = match m_echoBufferSize {
928                        _serde::__private::Some(__field) => __field,
929                        _serde::__private::None => {
930                            #[cfg(feature = "strict")]
931                            return _serde::__private::Err(
932                                <__A::Error as _serde::de::Error>::missing_field(
933                                    "echoBufferSize",
934                                ),
935                            );
936                            #[cfg(not(feature = "strict"))] Default::default()
937                        }
938                    };
939                    let m_atEnd = match m_atEnd {
940                        _serde::__private::Some(__field) => __field,
941                        _serde::__private::None => {
942                            #[cfg(feature = "strict")]
943                            return _serde::__private::Err(
944                                <__A::Error as _serde::de::Error>::missing_field("atEnd"),
945                            );
946                            #[cfg(not(feature = "strict"))] Default::default()
947                        }
948                    };
949                    let m_ignoreStartTime = match m_ignoreStartTime {
950                        _serde::__private::Some(__field) => __field,
951                        _serde::__private::None => {
952                            #[cfg(feature = "strict")]
953                            return _serde::__private::Err(
954                                <__A::Error as _serde::de::Error>::missing_field(
955                                    "ignoreStartTime",
956                                ),
957                            );
958                            #[cfg(not(feature = "strict"))] Default::default()
959                        }
960                    };
961                    let m_pingPongBackward = match m_pingPongBackward {
962                        _serde::__private::Some(__field) => __field,
963                        _serde::__private::None => {
964                            #[cfg(feature = "strict")]
965                            return _serde::__private::Err(
966                                <__A::Error as _serde::de::Error>::missing_field(
967                                    "pingPongBackward",
968                                ),
969                            );
970                            #[cfg(not(feature = "strict"))] Default::default()
971                        }
972                    };
973                    let __ptr = None;
974                    let parent = hkBaseObject { __ptr };
975                    let parent = hkReferencedObject {
976                        __ptr,
977                        parent,
978                        ..Default::default()
979                    };
980                    let __ptr = __A::class_ptr(&mut __map);
981                    _serde::__private::Ok(hkbClipGeneratorInternalState {
982                        __ptr,
983                        parent,
984                        m_extractedMotion,
985                        m_echos,
986                        m_localTime,
987                        m_time,
988                        m_previousUserControlledTimeFraction,
989                        m_bufferSize,
990                        m_echoBufferSize,
991                        m_atEnd,
992                        m_ignoreStartTime,
993                        m_pingPongBackward,
994                    })
995                }
996            }
997            const FIELDS: &[&str] = &[
998                "extractedMotion",
999                "echos",
1000                "localTime",
1001                "time",
1002                "previousUserControlledTimeFraction",
1003                "bufferSize",
1004                "echoBufferSize",
1005                "atEnd",
1006                "ignoreStartTime",
1007                "pingPongBackward",
1008            ];
1009            _serde::Deserializer::deserialize_struct(
1010                deserializer,
1011                "hkbClipGeneratorInternalState",
1012                FIELDS,
1013                __hkbClipGeneratorInternalStateVisitor {
1014                    marker: _serde::__private::PhantomData::<
1015                        hkbClipGeneratorInternalState,
1016                    >,
1017                    lifetime: _serde::__private::PhantomData,
1018                },
1019            )
1020        }
1021    }
1022};