havok_classes/generated/
hkbGeneratorTransitionEffectInternalState_.rs

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