havok_classes/generated/
hkbGeneratorTransitionEffect_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbGeneratorTransitionEffect`
5/// - version: `1`
6/// - signature: `0x5f771b12`
7/// - size: ` 92`(x86)/`144`(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 hkbGeneratorTransitionEffect<'a> {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkbTransitionEffect<'a>,
31    /// # C++ Info
32    /// - name: `transitionGenerator`(ctype: `struct hkbGenerator*`)
33    /// - offset: ` 44`(x86)/` 80`(x86_64)
34    /// - type_size: `  4`(x86)/`  8`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "transitionGenerator"))]
36    #[cfg_attr(feature = "serde", serde(rename = "transitionGenerator"))]
37    pub m_transitionGenerator: Pointer,
38    /// # C++ Info
39    /// - name: `blendInDuration`(ctype: `hkReal`)
40    /// - offset: ` 48`(x86)/` 88`(x86_64)
41    /// - type_size: `  4`(x86)/`  4`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "blendInDuration"))]
43    #[cfg_attr(feature = "serde", serde(rename = "blendInDuration"))]
44    pub m_blendInDuration: f32,
45    /// # C++ Info
46    /// - name: `blendOutDuration`(ctype: `hkReal`)
47    /// - offset: ` 52`(x86)/` 92`(x86_64)
48    /// - type_size: `  4`(x86)/`  4`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "blendOutDuration"))]
50    #[cfg_attr(feature = "serde", serde(rename = "blendOutDuration"))]
51    pub m_blendOutDuration: f32,
52    /// # C++ Info
53    /// - name: `syncToGeneratorStartTime`(ctype: `hkBool`)
54    /// - offset: ` 56`(x86)/` 96`(x86_64)
55    /// - type_size: `  1`(x86)/`  1`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "syncToGeneratorStartTime"))]
57    #[cfg_attr(feature = "serde", serde(rename = "syncToGeneratorStartTime"))]
58    pub m_syncToGeneratorStartTime: bool,
59    /// # C++ Info
60    /// - name: `fromGenerator`(ctype: `void*`)
61    /// - offset: ` 60`(x86)/`104`(x86_64)
62    /// - type_size: `  4`(x86)/`  8`(x86_64)
63    /// - flags: `SERIALIZE_IGNORED`
64    #[cfg_attr(feature = "json_schema", schemars(rename = "fromGenerator"))]
65    #[cfg_attr(feature = "serde", serde(rename = "fromGenerator"))]
66    pub m_fromGenerator: Pointer,
67    /// # C++ Info
68    /// - name: `toGenerator`(ctype: `void*`)
69    /// - offset: ` 64`(x86)/`112`(x86_64)
70    /// - type_size: `  4`(x86)/`  8`(x86_64)
71    /// - flags: `SERIALIZE_IGNORED`
72    #[cfg_attr(feature = "json_schema", schemars(rename = "toGenerator"))]
73    #[cfg_attr(feature = "serde", serde(rename = "toGenerator"))]
74    pub m_toGenerator: Pointer,
75    /// # C++ Info
76    /// - name: `timeInTransition`(ctype: `hkReal`)
77    /// - offset: ` 68`(x86)/`120`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    /// - flags: `SERIALIZE_IGNORED`
80    #[cfg_attr(feature = "json_schema", schemars(rename = "timeInTransition"))]
81    #[cfg_attr(feature = "serde", serde(rename = "timeInTransition"))]
82    pub m_timeInTransition: f32,
83    /// # C++ Info
84    /// - name: `duration`(ctype: `hkReal`)
85    /// - offset: ` 72`(x86)/`124`(x86_64)
86    /// - type_size: `  4`(x86)/`  4`(x86_64)
87    /// - flags: `SERIALIZE_IGNORED`
88    #[cfg_attr(feature = "json_schema", schemars(rename = "duration"))]
89    #[cfg_attr(feature = "serde", serde(rename = "duration"))]
90    pub m_duration: f32,
91    /// # C++ Info
92    /// - name: `effectiveBlendInDuration`(ctype: `hkReal`)
93    /// - offset: ` 76`(x86)/`128`(x86_64)
94    /// - type_size: `  4`(x86)/`  4`(x86_64)
95    /// - flags: `SERIALIZE_IGNORED`
96    #[cfg_attr(feature = "json_schema", schemars(rename = "effectiveBlendInDuration"))]
97    #[cfg_attr(feature = "serde", serde(rename = "effectiveBlendInDuration"))]
98    pub m_effectiveBlendInDuration: f32,
99    /// # C++ Info
100    /// - name: `effectiveBlendOutDuration`(ctype: `hkReal`)
101    /// - offset: ` 80`(x86)/`132`(x86_64)
102    /// - type_size: `  4`(x86)/`  4`(x86_64)
103    /// - flags: `SERIALIZE_IGNORED`
104    #[cfg_attr(feature = "json_schema", schemars(rename = "effectiveBlendOutDuration"))]
105    #[cfg_attr(feature = "serde", serde(rename = "effectiveBlendOutDuration"))]
106    pub m_effectiveBlendOutDuration: f32,
107    /// # C++ Info
108    /// - name: `toGeneratorState`(ctype: `enum unknown`)
109    /// - offset: ` 84`(x86)/`136`(x86_64)
110    /// - type_size: `  1`(x86)/`  1`(x86_64)
111    /// - flags: `SERIALIZE_IGNORED`
112    #[cfg_attr(feature = "json_schema", schemars(rename = "toGeneratorState"))]
113    #[cfg_attr(feature = "serde", serde(rename = "toGeneratorState"))]
114    pub m_toGeneratorState: i8,
115    /// # C++ Info
116    /// - name: `echoTransitionGenerator`(ctype: `hkBool`)
117    /// - offset: ` 85`(x86)/`137`(x86_64)
118    /// - type_size: `  1`(x86)/`  1`(x86_64)
119    /// - flags: `SERIALIZE_IGNORED`
120    #[cfg_attr(feature = "json_schema", schemars(rename = "echoTransitionGenerator"))]
121    #[cfg_attr(feature = "serde", serde(rename = "echoTransitionGenerator"))]
122    pub m_echoTransitionGenerator: bool,
123    /// # C++ Info
124    /// - name: `echoToGenerator`(ctype: `hkBool`)
125    /// - offset: ` 86`(x86)/`138`(x86_64)
126    /// - type_size: `  1`(x86)/`  1`(x86_64)
127    /// - flags: `SERIALIZE_IGNORED`
128    #[cfg_attr(feature = "json_schema", schemars(rename = "echoToGenerator"))]
129    #[cfg_attr(feature = "serde", serde(rename = "echoToGenerator"))]
130    pub m_echoToGenerator: bool,
131    /// # C++ Info
132    /// - name: `justActivated`(ctype: `hkBool`)
133    /// - offset: ` 87`(x86)/`139`(x86_64)
134    /// - type_size: `  1`(x86)/`  1`(x86_64)
135    /// - flags: `SERIALIZE_IGNORED`
136    #[cfg_attr(feature = "json_schema", schemars(rename = "justActivated"))]
137    #[cfg_attr(feature = "serde", serde(rename = "justActivated"))]
138    pub m_justActivated: bool,
139    /// # C++ Info
140    /// - name: `updateActiveNodes`(ctype: `hkBool`)
141    /// - offset: ` 88`(x86)/`140`(x86_64)
142    /// - type_size: `  1`(x86)/`  1`(x86_64)
143    /// - flags: `SERIALIZE_IGNORED`
144    #[cfg_attr(feature = "json_schema", schemars(rename = "updateActiveNodes"))]
145    #[cfg_attr(feature = "serde", serde(rename = "updateActiveNodes"))]
146    pub m_updateActiveNodes: bool,
147    /// # C++ Info
148    /// - name: `stage`(ctype: `enum unknown`)
149    /// - offset: ` 89`(x86)/`141`(x86_64)
150    /// - type_size: `  1`(x86)/`  1`(x86_64)
151    /// - flags: `SERIALIZE_IGNORED`
152    #[cfg_attr(feature = "json_schema", schemars(rename = "stage"))]
153    #[cfg_attr(feature = "serde", serde(rename = "stage"))]
154    pub m_stage: i8,
155}
156const _: () = {
157    use havok_serde as _serde;
158    impl<'a> _serde::HavokClass for hkbGeneratorTransitionEffect<'a> {
159        #[inline]
160        fn name(&self) -> &'static str {
161            "hkbGeneratorTransitionEffect"
162        }
163        #[inline]
164        fn signature(&self) -> _serde::__private::Signature {
165            _serde::__private::Signature::new(0x5f771b12)
166        }
167        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
168        fn deps_indexes(&self) -> Vec<usize> {
169            let mut v = Vec::new();
170            v.push(self.parent.parent.parent.parent.m_variableBindingSet.get());
171            v.push(self.m_transitionGenerator.get());
172            v.push(self.m_fromGenerator.get());
173            v.push(self.m_toGenerator.get());
174            v
175        }
176    }
177    impl<'a> _serde::Serialize for hkbGeneratorTransitionEffect<'a> {
178        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
179        where
180            S: _serde::ser::Serializer,
181        {
182            let class_meta = self
183                .__ptr
184                .map(|name| (name, _serde::__private::Signature::new(0x5f771b12)));
185            let mut serializer = __serializer
186                .serialize_struct(
187                    "hkbGeneratorTransitionEffect",
188                    class_meta,
189                    (92u64, 144u64),
190                )?;
191            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
192            serializer
193                .skip_field(
194                    "memSizeAndFlags",
195                    &self.parent.parent.parent.parent.parent.m_memSizeAndFlags,
196                )?;
197            serializer
198                .skip_field(
199                    "referenceCount",
200                    &self.parent.parent.parent.parent.parent.m_referenceCount,
201                )?;
202            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
203            serializer
204                .serialize_field(
205                    "variableBindingSet",
206                    &self.parent.parent.parent.parent.m_variableBindingSet,
207                )?;
208            serializer
209                .skip_array_field(
210                    "cachedBindables",
211                    &self.parent.parent.parent.parent.m_cachedBindables,
212                    TypeSize::NonPtr,
213                )?;
214            serializer
215                .skip_field(
216                    "areBindablesCached",
217                    &self.parent.parent.parent.parent.m_areBindablesCached,
218                )?;
219            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
220            serializer
221                .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
222            serializer.serialize_field("name", &self.parent.parent.parent.m_name)?;
223            serializer.skip_field("id", &self.parent.parent.parent.m_id)?;
224            serializer
225                .skip_field("cloneState", &self.parent.parent.parent.m_cloneState)?;
226            serializer
227                .skip_fixed_array_field(
228                    "padNode",
229                    self.parent.parent.parent.m_padNode.as_slice(),
230                    TypeSize::NonPtr,
231                )?;
232            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
233            serializer
234                .serialize_field(
235                    "selfTransitionMode",
236                    &self.parent.m_selfTransitionMode,
237                )?;
238            serializer.serialize_field("eventMode", &self.parent.m_eventMode)?;
239            serializer.skip_field("defaultEventMode", &self.parent.m_defaultEventMode)?;
240            serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 5usize].as_slice())?;
241            serializer
242                .serialize_field("transitionGenerator", &self.m_transitionGenerator)?;
243            serializer.serialize_field("blendInDuration", &self.m_blendInDuration)?;
244            serializer.serialize_field("blendOutDuration", &self.m_blendOutDuration)?;
245            serializer
246                .serialize_field(
247                    "syncToGeneratorStartTime",
248                    &self.m_syncToGeneratorStartTime,
249                )?;
250            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
251            serializer.skip_field("fromGenerator", &self.m_fromGenerator)?;
252            serializer.skip_field("toGenerator", &self.m_toGenerator)?;
253            serializer.skip_field("timeInTransition", &self.m_timeInTransition)?;
254            serializer.skip_field("duration", &self.m_duration)?;
255            serializer
256                .skip_field(
257                    "effectiveBlendInDuration",
258                    &self.m_effectiveBlendInDuration,
259                )?;
260            serializer
261                .skip_field(
262                    "effectiveBlendOutDuration",
263                    &self.m_effectiveBlendOutDuration,
264                )?;
265            serializer.skip_field("toGeneratorState", &self.m_toGeneratorState)?;
266            serializer
267                .skip_field("echoTransitionGenerator", &self.m_echoTransitionGenerator)?;
268            serializer.skip_field("echoToGenerator", &self.m_echoToGenerator)?;
269            serializer.skip_field("justActivated", &self.m_justActivated)?;
270            serializer.skip_field("updateActiveNodes", &self.m_updateActiveNodes)?;
271            serializer.skip_field("stage", &self.m_stage)?;
272            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
273            serializer.end()
274        }
275    }
276};
277#[doc(hidden)]
278#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
279const _: () = {
280    use havok_serde as _serde;
281    #[automatically_derived]
282    impl<'de> _serde::Deserialize<'de> for hkbGeneratorTransitionEffect<'de> {
283        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
284        where
285            __D: _serde::Deserializer<'de>,
286        {
287            #[allow(non_camel_case_types)]
288            enum __Field {
289                m_variableBindingSet,
290                m_userData,
291                m_name,
292                m_selfTransitionMode,
293                m_eventMode,
294                m_transitionGenerator,
295                m_blendInDuration,
296                m_blendOutDuration,
297                m_syncToGeneratorStartTime,
298                __ignore,
299            }
300            struct __FieldVisitor;
301            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
302                type Value = __Field;
303                fn expecting(
304                    &self,
305                    __formatter: &mut core::fmt::Formatter,
306                ) -> core::fmt::Result {
307                    core::fmt::Formatter::write_str(__formatter, "field identifier")
308                }
309                /// Intended for use in XML.
310                #[allow(clippy::match_single_binding)]
311                #[allow(clippy::reversed_empty_ranges)]
312                #[allow(clippy::single_match)]
313                fn visit_key<__E>(
314                    self,
315                    __value: &str,
316                ) -> core::result::Result<Self::Value, __E>
317                where
318                    __E: _serde::de::Error,
319                {
320                    match __value {
321                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
322                        "userData" => Ok(__Field::m_userData),
323                        "name" => Ok(__Field::m_name),
324                        "selfTransitionMode" => Ok(__Field::m_selfTransitionMode),
325                        "eventMode" => Ok(__Field::m_eventMode),
326                        "transitionGenerator" => Ok(__Field::m_transitionGenerator),
327                        "blendInDuration" => Ok(__Field::m_blendInDuration),
328                        "blendOutDuration" => Ok(__Field::m_blendOutDuration),
329                        "syncToGeneratorStartTime" => {
330                            Ok(__Field::m_syncToGeneratorStartTime)
331                        }
332                        _ => Ok(__Field::__ignore),
333                    }
334                }
335            }
336            impl<'de> _serde::Deserialize<'de> for __Field {
337                #[inline]
338                fn deserialize<__D>(
339                    __deserializer: __D,
340                ) -> core::result::Result<Self, __D::Error>
341                where
342                    __D: _serde::Deserializer<'de>,
343                {
344                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
345                }
346            }
347            struct __hkbGeneratorTransitionEffectVisitor<'de> {
348                marker: _serde::__private::PhantomData<
349                    hkbGeneratorTransitionEffect<'de>,
350                >,
351                lifetime: _serde::__private::PhantomData<&'de ()>,
352            }
353            #[allow(clippy::match_single_binding)]
354            #[allow(clippy::reversed_empty_ranges)]
355            #[allow(clippy::single_match)]
356            impl<'de> _serde::de::Visitor<'de>
357            for __hkbGeneratorTransitionEffectVisitor<'de> {
358                type Value = hkbGeneratorTransitionEffect<'de>;
359                fn expecting(
360                    &self,
361                    __formatter: &mut core::fmt::Formatter,
362                ) -> core::fmt::Result {
363                    core::fmt::Formatter::write_str(
364                        __formatter,
365                        "struct hkbGeneratorTransitionEffect",
366                    )
367                }
368                fn visit_struct_for_bytes<__A>(
369                    self,
370                    mut __map: __A,
371                ) -> _serde::__private::Result<Self::Value, __A::Error>
372                where
373                    __A: _serde::de::MapAccess<'de>,
374                {
375                    let __ptr = __A::class_ptr(&mut __map);
376                    let parent = __A::parent_value(&mut __map)?;
377                    let mut m_transitionGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
378                    let mut m_blendInDuration: _serde::__private::Option<f32> = _serde::__private::None;
379                    let mut m_blendOutDuration: _serde::__private::Option<f32> = _serde::__private::None;
380                    let mut m_syncToGeneratorStartTime: _serde::__private::Option<
381                        bool,
382                    > = _serde::__private::None;
383                    let mut m_fromGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
384                    let mut m_toGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
385                    let mut m_timeInTransition: _serde::__private::Option<f32> = _serde::__private::None;
386                    let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
387                    let mut m_effectiveBlendInDuration: _serde::__private::Option<f32> = _serde::__private::None;
388                    let mut m_effectiveBlendOutDuration: _serde::__private::Option<
389                        f32,
390                    > = _serde::__private::None;
391                    let mut m_toGeneratorState: _serde::__private::Option<i8> = _serde::__private::None;
392                    let mut m_echoTransitionGenerator: _serde::__private::Option<bool> = _serde::__private::None;
393                    let mut m_echoToGenerator: _serde::__private::Option<bool> = _serde::__private::None;
394                    let mut m_justActivated: _serde::__private::Option<bool> = _serde::__private::None;
395                    let mut m_updateActiveNodes: _serde::__private::Option<bool> = _serde::__private::None;
396                    let mut m_stage: _serde::__private::Option<i8> = _serde::__private::None;
397                    for i in 0..16usize {
398                        match i {
399                            0usize => {
400                                if _serde::__private::Option::is_some(
401                                    &m_transitionGenerator,
402                                ) {
403                                    return _serde::__private::Err(
404                                        <__A::Error as _serde::de::Error>::duplicate_field(
405                                            "transitionGenerator",
406                                        ),
407                                    );
408                                }
409                                m_transitionGenerator = _serde::__private::Some(
410                                    match __A::next_value::<Pointer>(&mut __map) {
411                                        _serde::__private::Ok(__val) => __val,
412                                        _serde::__private::Err(__err) => {
413                                            return _serde::__private::Err(__err);
414                                        }
415                                    },
416                                );
417                            }
418                            1usize => {
419                                if _serde::__private::Option::is_some(&m_blendInDuration) {
420                                    return _serde::__private::Err(
421                                        <__A::Error as _serde::de::Error>::duplicate_field(
422                                            "blendInDuration",
423                                        ),
424                                    );
425                                }
426                                m_blendInDuration = _serde::__private::Some(
427                                    match __A::next_value::<f32>(&mut __map) {
428                                        _serde::__private::Ok(__val) => __val,
429                                        _serde::__private::Err(__err) => {
430                                            return _serde::__private::Err(__err);
431                                        }
432                                    },
433                                );
434                            }
435                            2usize => {
436                                if _serde::__private::Option::is_some(&m_blendOutDuration) {
437                                    return _serde::__private::Err(
438                                        <__A::Error as _serde::de::Error>::duplicate_field(
439                                            "blendOutDuration",
440                                        ),
441                                    );
442                                }
443                                m_blendOutDuration = _serde::__private::Some(
444                                    match __A::next_value::<f32>(&mut __map) {
445                                        _serde::__private::Ok(__val) => __val,
446                                        _serde::__private::Err(__err) => {
447                                            return _serde::__private::Err(__err);
448                                        }
449                                    },
450                                );
451                            }
452                            3usize => {
453                                if _serde::__private::Option::is_some(
454                                    &m_syncToGeneratorStartTime,
455                                ) {
456                                    return _serde::__private::Err(
457                                        <__A::Error as _serde::de::Error>::duplicate_field(
458                                            "syncToGeneratorStartTime",
459                                        ),
460                                    );
461                                }
462                                m_syncToGeneratorStartTime = _serde::__private::Some(
463                                    match __A::next_value::<bool>(&mut __map) {
464                                        _serde::__private::Ok(__val) => __val,
465                                        _serde::__private::Err(__err) => {
466                                            return _serde::__private::Err(__err);
467                                        }
468                                    },
469                                );
470                            }
471                            4usize => {
472                                if _serde::__private::Option::is_some(&m_fromGenerator) {
473                                    return _serde::__private::Err(
474                                        <__A::Error as _serde::de::Error>::duplicate_field(
475                                            "fromGenerator",
476                                        ),
477                                    );
478                                }
479                                __A::pad(&mut __map, 3usize, 7usize)?;
480                                m_fromGenerator = _serde::__private::Some(
481                                    match __A::next_value::<Pointer>(&mut __map) {
482                                        _serde::__private::Ok(__val) => __val,
483                                        _serde::__private::Err(__err) => {
484                                            return _serde::__private::Err(__err);
485                                        }
486                                    },
487                                );
488                            }
489                            5usize => {
490                                if _serde::__private::Option::is_some(&m_toGenerator) {
491                                    return _serde::__private::Err(
492                                        <__A::Error as _serde::de::Error>::duplicate_field(
493                                            "toGenerator",
494                                        ),
495                                    );
496                                }
497                                m_toGenerator = _serde::__private::Some(
498                                    match __A::next_value::<Pointer>(&mut __map) {
499                                        _serde::__private::Ok(__val) => __val,
500                                        _serde::__private::Err(__err) => {
501                                            return _serde::__private::Err(__err);
502                                        }
503                                    },
504                                );
505                            }
506                            6usize => {
507                                if _serde::__private::Option::is_some(&m_timeInTransition) {
508                                    return _serde::__private::Err(
509                                        <__A::Error as _serde::de::Error>::duplicate_field(
510                                            "timeInTransition",
511                                        ),
512                                    );
513                                }
514                                m_timeInTransition = _serde::__private::Some(
515                                    match __A::next_value::<f32>(&mut __map) {
516                                        _serde::__private::Ok(__val) => __val,
517                                        _serde::__private::Err(__err) => {
518                                            return _serde::__private::Err(__err);
519                                        }
520                                    },
521                                );
522                            }
523                            7usize => {
524                                if _serde::__private::Option::is_some(&m_duration) {
525                                    return _serde::__private::Err(
526                                        <__A::Error as _serde::de::Error>::duplicate_field(
527                                            "duration",
528                                        ),
529                                    );
530                                }
531                                m_duration = _serde::__private::Some(
532                                    match __A::next_value::<f32>(&mut __map) {
533                                        _serde::__private::Ok(__val) => __val,
534                                        _serde::__private::Err(__err) => {
535                                            return _serde::__private::Err(__err);
536                                        }
537                                    },
538                                );
539                            }
540                            8usize => {
541                                if _serde::__private::Option::is_some(
542                                    &m_effectiveBlendInDuration,
543                                ) {
544                                    return _serde::__private::Err(
545                                        <__A::Error as _serde::de::Error>::duplicate_field(
546                                            "effectiveBlendInDuration",
547                                        ),
548                                    );
549                                }
550                                m_effectiveBlendInDuration = _serde::__private::Some(
551                                    match __A::next_value::<f32>(&mut __map) {
552                                        _serde::__private::Ok(__val) => __val,
553                                        _serde::__private::Err(__err) => {
554                                            return _serde::__private::Err(__err);
555                                        }
556                                    },
557                                );
558                            }
559                            9usize => {
560                                if _serde::__private::Option::is_some(
561                                    &m_effectiveBlendOutDuration,
562                                ) {
563                                    return _serde::__private::Err(
564                                        <__A::Error as _serde::de::Error>::duplicate_field(
565                                            "effectiveBlendOutDuration",
566                                        ),
567                                    );
568                                }
569                                m_effectiveBlendOutDuration = _serde::__private::Some(
570                                    match __A::next_value::<f32>(&mut __map) {
571                                        _serde::__private::Ok(__val) => __val,
572                                        _serde::__private::Err(__err) => {
573                                            return _serde::__private::Err(__err);
574                                        }
575                                    },
576                                );
577                            }
578                            10usize => {
579                                if _serde::__private::Option::is_some(&m_toGeneratorState) {
580                                    return _serde::__private::Err(
581                                        <__A::Error as _serde::de::Error>::duplicate_field(
582                                            "toGeneratorState",
583                                        ),
584                                    );
585                                }
586                                m_toGeneratorState = _serde::__private::Some(
587                                    match __A::next_value::<i8>(&mut __map) {
588                                        _serde::__private::Ok(__val) => __val,
589                                        _serde::__private::Err(__err) => {
590                                            return _serde::__private::Err(__err);
591                                        }
592                                    },
593                                );
594                            }
595                            11usize => {
596                                if _serde::__private::Option::is_some(
597                                    &m_echoTransitionGenerator,
598                                ) {
599                                    return _serde::__private::Err(
600                                        <__A::Error as _serde::de::Error>::duplicate_field(
601                                            "echoTransitionGenerator",
602                                        ),
603                                    );
604                                }
605                                m_echoTransitionGenerator = _serde::__private::Some(
606                                    match __A::next_value::<bool>(&mut __map) {
607                                        _serde::__private::Ok(__val) => __val,
608                                        _serde::__private::Err(__err) => {
609                                            return _serde::__private::Err(__err);
610                                        }
611                                    },
612                                );
613                            }
614                            12usize => {
615                                if _serde::__private::Option::is_some(&m_echoToGenerator) {
616                                    return _serde::__private::Err(
617                                        <__A::Error as _serde::de::Error>::duplicate_field(
618                                            "echoToGenerator",
619                                        ),
620                                    );
621                                }
622                                m_echoToGenerator = _serde::__private::Some(
623                                    match __A::next_value::<bool>(&mut __map) {
624                                        _serde::__private::Ok(__val) => __val,
625                                        _serde::__private::Err(__err) => {
626                                            return _serde::__private::Err(__err);
627                                        }
628                                    },
629                                );
630                            }
631                            13usize => {
632                                if _serde::__private::Option::is_some(&m_justActivated) {
633                                    return _serde::__private::Err(
634                                        <__A::Error as _serde::de::Error>::duplicate_field(
635                                            "justActivated",
636                                        ),
637                                    );
638                                }
639                                m_justActivated = _serde::__private::Some(
640                                    match __A::next_value::<bool>(&mut __map) {
641                                        _serde::__private::Ok(__val) => __val,
642                                        _serde::__private::Err(__err) => {
643                                            return _serde::__private::Err(__err);
644                                        }
645                                    },
646                                );
647                            }
648                            14usize => {
649                                if _serde::__private::Option::is_some(
650                                    &m_updateActiveNodes,
651                                ) {
652                                    return _serde::__private::Err(
653                                        <__A::Error as _serde::de::Error>::duplicate_field(
654                                            "updateActiveNodes",
655                                        ),
656                                    );
657                                }
658                                m_updateActiveNodes = _serde::__private::Some(
659                                    match __A::next_value::<bool>(&mut __map) {
660                                        _serde::__private::Ok(__val) => __val,
661                                        _serde::__private::Err(__err) => {
662                                            return _serde::__private::Err(__err);
663                                        }
664                                    },
665                                );
666                            }
667                            15usize => {
668                                if _serde::__private::Option::is_some(&m_stage) {
669                                    return _serde::__private::Err(
670                                        <__A::Error as _serde::de::Error>::duplicate_field("stage"),
671                                    );
672                                }
673                                m_stage = _serde::__private::Some(
674                                    match __A::next_value::<i8>(&mut __map) {
675                                        _serde::__private::Ok(__val) => __val,
676                                        _serde::__private::Err(__err) => {
677                                            return _serde::__private::Err(__err);
678                                        }
679                                    },
680                                );
681                            }
682                            _ => {}
683                        }
684                    }
685                    __A::pad(&mut __map, 2usize, 2usize)?;
686                    let m_transitionGenerator = match m_transitionGenerator {
687                        _serde::__private::Some(__field) => __field,
688                        _serde::__private::None => {
689                            return _serde::__private::Err(
690                                <__A::Error as _serde::de::Error>::missing_field(
691                                    "transitionGenerator",
692                                ),
693                            );
694                        }
695                    };
696                    let m_blendInDuration = match m_blendInDuration {
697                        _serde::__private::Some(__field) => __field,
698                        _serde::__private::None => {
699                            return _serde::__private::Err(
700                                <__A::Error as _serde::de::Error>::missing_field(
701                                    "blendInDuration",
702                                ),
703                            );
704                        }
705                    };
706                    let m_blendOutDuration = match m_blendOutDuration {
707                        _serde::__private::Some(__field) => __field,
708                        _serde::__private::None => {
709                            return _serde::__private::Err(
710                                <__A::Error as _serde::de::Error>::missing_field(
711                                    "blendOutDuration",
712                                ),
713                            );
714                        }
715                    };
716                    let m_syncToGeneratorStartTime = match m_syncToGeneratorStartTime {
717                        _serde::__private::Some(__field) => __field,
718                        _serde::__private::None => {
719                            return _serde::__private::Err(
720                                <__A::Error as _serde::de::Error>::missing_field(
721                                    "syncToGeneratorStartTime",
722                                ),
723                            );
724                        }
725                    };
726                    let m_fromGenerator = match m_fromGenerator {
727                        _serde::__private::Some(__field) => __field,
728                        _serde::__private::None => {
729                            return _serde::__private::Err(
730                                <__A::Error as _serde::de::Error>::missing_field(
731                                    "fromGenerator",
732                                ),
733                            );
734                        }
735                    };
736                    let m_toGenerator = match m_toGenerator {
737                        _serde::__private::Some(__field) => __field,
738                        _serde::__private::None => {
739                            return _serde::__private::Err(
740                                <__A::Error as _serde::de::Error>::missing_field(
741                                    "toGenerator",
742                                ),
743                            );
744                        }
745                    };
746                    let m_timeInTransition = match m_timeInTransition {
747                        _serde::__private::Some(__field) => __field,
748                        _serde::__private::None => {
749                            return _serde::__private::Err(
750                                <__A::Error as _serde::de::Error>::missing_field(
751                                    "timeInTransition",
752                                ),
753                            );
754                        }
755                    };
756                    let m_duration = match m_duration {
757                        _serde::__private::Some(__field) => __field,
758                        _serde::__private::None => {
759                            return _serde::__private::Err(
760                                <__A::Error as _serde::de::Error>::missing_field("duration"),
761                            );
762                        }
763                    };
764                    let m_effectiveBlendInDuration = match m_effectiveBlendInDuration {
765                        _serde::__private::Some(__field) => __field,
766                        _serde::__private::None => {
767                            return _serde::__private::Err(
768                                <__A::Error as _serde::de::Error>::missing_field(
769                                    "effectiveBlendInDuration",
770                                ),
771                            );
772                        }
773                    };
774                    let m_effectiveBlendOutDuration = match m_effectiveBlendOutDuration {
775                        _serde::__private::Some(__field) => __field,
776                        _serde::__private::None => {
777                            return _serde::__private::Err(
778                                <__A::Error as _serde::de::Error>::missing_field(
779                                    "effectiveBlendOutDuration",
780                                ),
781                            );
782                        }
783                    };
784                    let m_toGeneratorState = match m_toGeneratorState {
785                        _serde::__private::Some(__field) => __field,
786                        _serde::__private::None => {
787                            return _serde::__private::Err(
788                                <__A::Error as _serde::de::Error>::missing_field(
789                                    "toGeneratorState",
790                                ),
791                            );
792                        }
793                    };
794                    let m_echoTransitionGenerator = match m_echoTransitionGenerator {
795                        _serde::__private::Some(__field) => __field,
796                        _serde::__private::None => {
797                            return _serde::__private::Err(
798                                <__A::Error as _serde::de::Error>::missing_field(
799                                    "echoTransitionGenerator",
800                                ),
801                            );
802                        }
803                    };
804                    let m_echoToGenerator = match m_echoToGenerator {
805                        _serde::__private::Some(__field) => __field,
806                        _serde::__private::None => {
807                            return _serde::__private::Err(
808                                <__A::Error as _serde::de::Error>::missing_field(
809                                    "echoToGenerator",
810                                ),
811                            );
812                        }
813                    };
814                    let m_justActivated = match m_justActivated {
815                        _serde::__private::Some(__field) => __field,
816                        _serde::__private::None => {
817                            return _serde::__private::Err(
818                                <__A::Error as _serde::de::Error>::missing_field(
819                                    "justActivated",
820                                ),
821                            );
822                        }
823                    };
824                    let m_updateActiveNodes = match m_updateActiveNodes {
825                        _serde::__private::Some(__field) => __field,
826                        _serde::__private::None => {
827                            return _serde::__private::Err(
828                                <__A::Error as _serde::de::Error>::missing_field(
829                                    "updateActiveNodes",
830                                ),
831                            );
832                        }
833                    };
834                    let m_stage = match m_stage {
835                        _serde::__private::Some(__field) => __field,
836                        _serde::__private::None => {
837                            return _serde::__private::Err(
838                                <__A::Error as _serde::de::Error>::missing_field("stage"),
839                            );
840                        }
841                    };
842                    _serde::__private::Ok(hkbGeneratorTransitionEffect {
843                        __ptr,
844                        parent,
845                        m_transitionGenerator,
846                        m_blendInDuration,
847                        m_blendOutDuration,
848                        m_syncToGeneratorStartTime,
849                        m_fromGenerator,
850                        m_toGenerator,
851                        m_timeInTransition,
852                        m_duration,
853                        m_effectiveBlendInDuration,
854                        m_effectiveBlendOutDuration,
855                        m_toGeneratorState,
856                        m_echoTransitionGenerator,
857                        m_echoToGenerator,
858                        m_justActivated,
859                        m_updateActiveNodes,
860                        m_stage,
861                    })
862                }
863                #[allow(clippy::manual_unwrap_or_default)]
864                fn visit_struct<__A>(
865                    self,
866                    mut __map: __A,
867                ) -> _serde::__private::Result<Self::Value, __A::Error>
868                where
869                    __A: _serde::de::MapAccess<'de>,
870                {
871                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
872                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
873                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
874                    let mut m_selfTransitionMode: _serde::__private::Option<
875                        SelfTransitionMode,
876                    > = _serde::__private::None;
877                    let mut m_eventMode: _serde::__private::Option<EventMode> = _serde::__private::None;
878                    let mut m_transitionGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
879                    let mut m_blendInDuration: _serde::__private::Option<f32> = _serde::__private::None;
880                    let mut m_blendOutDuration: _serde::__private::Option<f32> = _serde::__private::None;
881                    let mut m_syncToGeneratorStartTime: _serde::__private::Option<
882                        bool,
883                    > = _serde::__private::None;
884                    while let _serde::__private::Some(__key) = {
885                        __A::next_key::<__Field>(&mut __map)?
886                    } {
887                        match __key {
888                            __Field::m_variableBindingSet => {
889                                #[cfg(
890                                    any(feature = "strict", feature = "ignore_duplicates")
891                                )]
892                                if _serde::__private::Option::is_some(
893                                    &m_variableBindingSet,
894                                ) {
895                                    #[cfg(feature = "ignore_duplicates")]
896                                    {
897                                        __A::skip_value(&mut __map)?;
898                                        continue;
899                                    }
900                                    #[cfg(feature = "strict")]
901                                    return _serde::__private::Err(
902                                        <__A::Error as _serde::de::Error>::duplicate_field(
903                                            "variableBindingSet",
904                                        ),
905                                    );
906                                }
907                                m_variableBindingSet = _serde::__private::Some(
908                                    match __A::next_value::<Pointer>(&mut __map) {
909                                        _serde::__private::Ok(__val) => __val,
910                                        _serde::__private::Err(__err) => {
911                                            return _serde::__private::Err(__err);
912                                        }
913                                    },
914                                );
915                            }
916                            __Field::m_userData => {
917                                #[cfg(
918                                    any(feature = "strict", feature = "ignore_duplicates")
919                                )]
920                                if _serde::__private::Option::is_some(&m_userData) {
921                                    #[cfg(feature = "ignore_duplicates")]
922                                    {
923                                        __A::skip_value(&mut __map)?;
924                                        continue;
925                                    }
926                                    #[cfg(feature = "strict")]
927                                    return _serde::__private::Err(
928                                        <__A::Error as _serde::de::Error>::duplicate_field(
929                                            "userData",
930                                        ),
931                                    );
932                                }
933                                m_userData = _serde::__private::Some(
934                                    match __A::next_value::<Ulong>(&mut __map) {
935                                        _serde::__private::Ok(__val) => __val,
936                                        _serde::__private::Err(__err) => {
937                                            return _serde::__private::Err(__err);
938                                        }
939                                    },
940                                );
941                            }
942                            __Field::m_name => {
943                                #[cfg(
944                                    any(feature = "strict", feature = "ignore_duplicates")
945                                )]
946                                if _serde::__private::Option::is_some(&m_name) {
947                                    #[cfg(feature = "ignore_duplicates")]
948                                    {
949                                        __A::skip_value(&mut __map)?;
950                                        continue;
951                                    }
952                                    #[cfg(feature = "strict")]
953                                    return _serde::__private::Err(
954                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
955                                    );
956                                }
957                                m_name = _serde::__private::Some(
958                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
959                                        _serde::__private::Ok(__val) => __val,
960                                        _serde::__private::Err(__err) => {
961                                            return _serde::__private::Err(__err);
962                                        }
963                                    },
964                                );
965                            }
966                            __Field::m_selfTransitionMode => {
967                                #[cfg(
968                                    any(feature = "strict", feature = "ignore_duplicates")
969                                )]
970                                if _serde::__private::Option::is_some(
971                                    &m_selfTransitionMode,
972                                ) {
973                                    #[cfg(feature = "ignore_duplicates")]
974                                    {
975                                        __A::skip_value(&mut __map)?;
976                                        continue;
977                                    }
978                                    #[cfg(feature = "strict")]
979                                    return _serde::__private::Err(
980                                        <__A::Error as _serde::de::Error>::duplicate_field(
981                                            "selfTransitionMode",
982                                        ),
983                                    );
984                                }
985                                m_selfTransitionMode = _serde::__private::Some(
986                                    match __A::next_value::<SelfTransitionMode>(&mut __map) {
987                                        _serde::__private::Ok(__val) => __val,
988                                        _serde::__private::Err(__err) => {
989                                            return _serde::__private::Err(__err);
990                                        }
991                                    },
992                                );
993                            }
994                            __Field::m_eventMode => {
995                                #[cfg(
996                                    any(feature = "strict", feature = "ignore_duplicates")
997                                )]
998                                if _serde::__private::Option::is_some(&m_eventMode) {
999                                    #[cfg(feature = "ignore_duplicates")]
1000                                    {
1001                                        __A::skip_value(&mut __map)?;
1002                                        continue;
1003                                    }
1004                                    #[cfg(feature = "strict")]
1005                                    return _serde::__private::Err(
1006                                        <__A::Error as _serde::de::Error>::duplicate_field(
1007                                            "eventMode",
1008                                        ),
1009                                    );
1010                                }
1011                                m_eventMode = _serde::__private::Some(
1012                                    match __A::next_value::<EventMode>(&mut __map) {
1013                                        _serde::__private::Ok(__val) => __val,
1014                                        _serde::__private::Err(__err) => {
1015                                            return _serde::__private::Err(__err);
1016                                        }
1017                                    },
1018                                );
1019                            }
1020                            __Field::m_transitionGenerator => {
1021                                #[cfg(
1022                                    any(feature = "strict", feature = "ignore_duplicates")
1023                                )]
1024                                if _serde::__private::Option::is_some(
1025                                    &m_transitionGenerator,
1026                                ) {
1027                                    #[cfg(feature = "ignore_duplicates")]
1028                                    {
1029                                        __A::skip_value(&mut __map)?;
1030                                        continue;
1031                                    }
1032                                    #[cfg(feature = "strict")]
1033                                    return _serde::__private::Err(
1034                                        <__A::Error as _serde::de::Error>::duplicate_field(
1035                                            "transitionGenerator",
1036                                        ),
1037                                    );
1038                                }
1039                                m_transitionGenerator = _serde::__private::Some(
1040                                    match __A::next_value::<Pointer>(&mut __map) {
1041                                        _serde::__private::Ok(__val) => __val,
1042                                        _serde::__private::Err(__err) => {
1043                                            return _serde::__private::Err(__err);
1044                                        }
1045                                    },
1046                                );
1047                            }
1048                            __Field::m_blendInDuration => {
1049                                #[cfg(
1050                                    any(feature = "strict", feature = "ignore_duplicates")
1051                                )]
1052                                if _serde::__private::Option::is_some(&m_blendInDuration) {
1053                                    #[cfg(feature = "ignore_duplicates")]
1054                                    {
1055                                        __A::skip_value(&mut __map)?;
1056                                        continue;
1057                                    }
1058                                    #[cfg(feature = "strict")]
1059                                    return _serde::__private::Err(
1060                                        <__A::Error as _serde::de::Error>::duplicate_field(
1061                                            "blendInDuration",
1062                                        ),
1063                                    );
1064                                }
1065                                m_blendInDuration = _serde::__private::Some(
1066                                    match __A::next_value::<f32>(&mut __map) {
1067                                        _serde::__private::Ok(__val) => __val,
1068                                        _serde::__private::Err(__err) => {
1069                                            return _serde::__private::Err(__err);
1070                                        }
1071                                    },
1072                                );
1073                            }
1074                            __Field::m_blendOutDuration => {
1075                                #[cfg(
1076                                    any(feature = "strict", feature = "ignore_duplicates")
1077                                )]
1078                                if _serde::__private::Option::is_some(&m_blendOutDuration) {
1079                                    #[cfg(feature = "ignore_duplicates")]
1080                                    {
1081                                        __A::skip_value(&mut __map)?;
1082                                        continue;
1083                                    }
1084                                    #[cfg(feature = "strict")]
1085                                    return _serde::__private::Err(
1086                                        <__A::Error as _serde::de::Error>::duplicate_field(
1087                                            "blendOutDuration",
1088                                        ),
1089                                    );
1090                                }
1091                                m_blendOutDuration = _serde::__private::Some(
1092                                    match __A::next_value::<f32>(&mut __map) {
1093                                        _serde::__private::Ok(__val) => __val,
1094                                        _serde::__private::Err(__err) => {
1095                                            return _serde::__private::Err(__err);
1096                                        }
1097                                    },
1098                                );
1099                            }
1100                            __Field::m_syncToGeneratorStartTime => {
1101                                #[cfg(
1102                                    any(feature = "strict", feature = "ignore_duplicates")
1103                                )]
1104                                if _serde::__private::Option::is_some(
1105                                    &m_syncToGeneratorStartTime,
1106                                ) {
1107                                    #[cfg(feature = "ignore_duplicates")]
1108                                    {
1109                                        __A::skip_value(&mut __map)?;
1110                                        continue;
1111                                    }
1112                                    #[cfg(feature = "strict")]
1113                                    return _serde::__private::Err(
1114                                        <__A::Error as _serde::de::Error>::duplicate_field(
1115                                            "syncToGeneratorStartTime",
1116                                        ),
1117                                    );
1118                                }
1119                                m_syncToGeneratorStartTime = _serde::__private::Some(
1120                                    match __A::next_value::<bool>(&mut __map) {
1121                                        _serde::__private::Ok(__val) => __val,
1122                                        _serde::__private::Err(__err) => {
1123                                            return _serde::__private::Err(__err);
1124                                        }
1125                                    },
1126                                );
1127                            }
1128                            _ => __A::skip_value(&mut __map)?,
1129                        }
1130                    }
1131                    let m_variableBindingSet = match m_variableBindingSet {
1132                        _serde::__private::Some(__field) => __field,
1133                        _serde::__private::None => {
1134                            #[cfg(feature = "strict")]
1135                            return _serde::__private::Err(
1136                                <__A::Error as _serde::de::Error>::missing_field(
1137                                    "variableBindingSet",
1138                                ),
1139                            );
1140                            #[cfg(not(feature = "strict"))] Default::default()
1141                        }
1142                    };
1143                    let m_userData = match m_userData {
1144                        _serde::__private::Some(__field) => __field,
1145                        _serde::__private::None => {
1146                            #[cfg(feature = "strict")]
1147                            return _serde::__private::Err(
1148                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1149                            );
1150                            #[cfg(not(feature = "strict"))] Default::default()
1151                        }
1152                    };
1153                    let m_name = match m_name {
1154                        _serde::__private::Some(__field) => __field,
1155                        _serde::__private::None => {
1156                            #[cfg(feature = "strict")]
1157                            return _serde::__private::Err(
1158                                <__A::Error as _serde::de::Error>::missing_field("name"),
1159                            );
1160                            #[cfg(not(feature = "strict"))] Default::default()
1161                        }
1162                    };
1163                    let m_selfTransitionMode = match m_selfTransitionMode {
1164                        _serde::__private::Some(__field) => __field,
1165                        _serde::__private::None => {
1166                            #[cfg(feature = "strict")]
1167                            return _serde::__private::Err(
1168                                <__A::Error as _serde::de::Error>::missing_field(
1169                                    "selfTransitionMode",
1170                                ),
1171                            );
1172                            #[cfg(not(feature = "strict"))] Default::default()
1173                        }
1174                    };
1175                    let m_eventMode = match m_eventMode {
1176                        _serde::__private::Some(__field) => __field,
1177                        _serde::__private::None => {
1178                            #[cfg(feature = "strict")]
1179                            return _serde::__private::Err(
1180                                <__A::Error as _serde::de::Error>::missing_field(
1181                                    "eventMode",
1182                                ),
1183                            );
1184                            #[cfg(not(feature = "strict"))] Default::default()
1185                        }
1186                    };
1187                    let m_transitionGenerator = match m_transitionGenerator {
1188                        _serde::__private::Some(__field) => __field,
1189                        _serde::__private::None => {
1190                            #[cfg(feature = "strict")]
1191                            return _serde::__private::Err(
1192                                <__A::Error as _serde::de::Error>::missing_field(
1193                                    "transitionGenerator",
1194                                ),
1195                            );
1196                            #[cfg(not(feature = "strict"))] Default::default()
1197                        }
1198                    };
1199                    let m_blendInDuration = match m_blendInDuration {
1200                        _serde::__private::Some(__field) => __field,
1201                        _serde::__private::None => {
1202                            #[cfg(feature = "strict")]
1203                            return _serde::__private::Err(
1204                                <__A::Error as _serde::de::Error>::missing_field(
1205                                    "blendInDuration",
1206                                ),
1207                            );
1208                            #[cfg(not(feature = "strict"))] Default::default()
1209                        }
1210                    };
1211                    let m_blendOutDuration = match m_blendOutDuration {
1212                        _serde::__private::Some(__field) => __field,
1213                        _serde::__private::None => {
1214                            #[cfg(feature = "strict")]
1215                            return _serde::__private::Err(
1216                                <__A::Error as _serde::de::Error>::missing_field(
1217                                    "blendOutDuration",
1218                                ),
1219                            );
1220                            #[cfg(not(feature = "strict"))] Default::default()
1221                        }
1222                    };
1223                    let m_syncToGeneratorStartTime = match m_syncToGeneratorStartTime {
1224                        _serde::__private::Some(__field) => __field,
1225                        _serde::__private::None => {
1226                            #[cfg(feature = "strict")]
1227                            return _serde::__private::Err(
1228                                <__A::Error as _serde::de::Error>::missing_field(
1229                                    "syncToGeneratorStartTime",
1230                                ),
1231                            );
1232                            #[cfg(not(feature = "strict"))] Default::default()
1233                        }
1234                    };
1235                    let __ptr = None;
1236                    let parent = hkBaseObject { __ptr };
1237                    let parent = hkReferencedObject {
1238                        __ptr,
1239                        parent,
1240                        ..Default::default()
1241                    };
1242                    let parent = hkbBindable {
1243                        __ptr,
1244                        parent,
1245                        m_variableBindingSet,
1246                        ..Default::default()
1247                    };
1248                    let parent = hkbNode {
1249                        __ptr,
1250                        parent,
1251                        m_userData,
1252                        m_name,
1253                        ..Default::default()
1254                    };
1255                    let parent = hkbGenerator { __ptr, parent };
1256                    let parent = hkbTransitionEffect {
1257                        __ptr,
1258                        parent,
1259                        m_selfTransitionMode,
1260                        m_eventMode,
1261                        ..Default::default()
1262                    };
1263                    let __ptr = __A::class_ptr(&mut __map);
1264                    _serde::__private::Ok(hkbGeneratorTransitionEffect {
1265                        __ptr,
1266                        parent,
1267                        m_transitionGenerator,
1268                        m_blendInDuration,
1269                        m_blendOutDuration,
1270                        m_syncToGeneratorStartTime,
1271                        ..Default::default()
1272                    })
1273                }
1274            }
1275            const FIELDS: &[&str] = &[
1276                "transitionGenerator",
1277                "blendInDuration",
1278                "blendOutDuration",
1279                "syncToGeneratorStartTime",
1280                "fromGenerator",
1281                "toGenerator",
1282                "timeInTransition",
1283                "duration",
1284                "effectiveBlendInDuration",
1285                "effectiveBlendOutDuration",
1286                "toGeneratorState",
1287                "echoTransitionGenerator",
1288                "echoToGenerator",
1289                "justActivated",
1290                "updateActiveNodes",
1291                "stage",
1292            ];
1293            _serde::Deserializer::deserialize_struct(
1294                deserializer,
1295                "hkbGeneratorTransitionEffect",
1296                FIELDS,
1297                __hkbGeneratorTransitionEffectVisitor {
1298                    marker: _serde::__private::PhantomData::<
1299                        hkbGeneratorTransitionEffect,
1300                    >,
1301                    lifetime: _serde::__private::PhantomData,
1302                },
1303            )
1304        }
1305    }
1306};
1307/// # C++ Info
1308/// - name: `ToGeneratorState`(ctype: `hkEnum<ToGeneratorState, hkInt8>`)
1309#[allow(non_upper_case_globals, non_snake_case)]
1310#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1311#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1312#[derive(
1313    Debug,
1314    Clone,
1315    Default,
1316    PartialEq,
1317    Eq,
1318    PartialOrd,
1319    Ord,
1320    num_derive::ToPrimitive,
1321    num_derive::FromPrimitive,
1322)]
1323pub enum ToGeneratorState {
1324    #[default]
1325    STATE_INACTIVE = 0isize,
1326    STATE_READY_FOR_SET_LOCAL_TIME = 1isize,
1327    STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE = 2isize,
1328    STATE_ACTIVE = 3isize,
1329}
1330/// # C++ Info
1331/// - name: `Stage`(ctype: `hkEnum<Stage, hkInt8>`)
1332#[allow(non_upper_case_globals, non_snake_case)]
1333#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1334#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1335#[derive(
1336    Debug,
1337    Clone,
1338    Default,
1339    PartialEq,
1340    Eq,
1341    PartialOrd,
1342    Ord,
1343    num_derive::ToPrimitive,
1344    num_derive::FromPrimitive,
1345)]
1346pub enum Stage {
1347    #[default]
1348    STAGE_BLENDING_IN = 0isize,
1349    STAGE_PLAYING_TRANSITION_GENERATOR = 1isize,
1350    STAGE_BLENDING_OUT = 2isize,
1351}
1352const _: () = {
1353    use havok_serde as __serde;
1354    impl __serde::Serialize for ToGeneratorState {
1355        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1356        where
1357            S: __serde::ser::Serializer,
1358        {
1359            let mut __serializer = __serializer.serialize_enum_flags()?;
1360            match self {
1361                Self::STATE_INACTIVE => {
1362                    __serializer.serialize_field("STATE_INACTIVE", &0u64)
1363                }
1364                Self::STATE_READY_FOR_SET_LOCAL_TIME => {
1365                    __serializer.serialize_field("STATE_READY_FOR_SET_LOCAL_TIME", &1u64)
1366                }
1367                Self::STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE => {
1368                    __serializer
1369                        .serialize_field(
1370                            "STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE",
1371                            &2u64,
1372                        )
1373                }
1374                Self::STATE_ACTIVE => __serializer.serialize_field("STATE_ACTIVE", &3u64),
1375            }?;
1376            use num_traits::ToPrimitive as _;
1377            let num = self
1378                .to_i8()
1379                .ok_or(S::Error::custom("Failed enum ToGeneratorState to_i8"))?;
1380            __serializer.serialize_bits(&num)?;
1381            __serializer.end()
1382        }
1383    }
1384};
1385const _: () = {
1386    use havok_serde as __serde;
1387    impl __serde::Serialize for Stage {
1388        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1389        where
1390            S: __serde::ser::Serializer,
1391        {
1392            let mut __serializer = __serializer.serialize_enum_flags()?;
1393            match self {
1394                Self::STAGE_BLENDING_IN => {
1395                    __serializer.serialize_field("STAGE_BLENDING_IN", &0u64)
1396                }
1397                Self::STAGE_PLAYING_TRANSITION_GENERATOR => {
1398                    __serializer
1399                        .serialize_field("STAGE_PLAYING_TRANSITION_GENERATOR", &1u64)
1400                }
1401                Self::STAGE_BLENDING_OUT => {
1402                    __serializer.serialize_field("STAGE_BLENDING_OUT", &2u64)
1403                }
1404            }?;
1405            use num_traits::ToPrimitive as _;
1406            let num = self.to_i8().ok_or(S::Error::custom("Failed enum Stage to_i8"))?;
1407            __serializer.serialize_bits(&num)?;
1408            __serializer.end()
1409        }
1410    }
1411};
1412#[doc(hidden)]
1413#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1414const _: () = {
1415    #[allow(unused_extern_crates, clippy::useless_attribute)]
1416    extern crate havok_serde as _serde;
1417    #[automatically_derived]
1418    impl<'de> _serde::Deserialize<'de> for ToGeneratorState {
1419        fn deserialize<__D>(
1420            __deserializer: __D,
1421        ) -> _serde::__private::Result<Self, __D::Error>
1422        where
1423            __D: _serde::Deserializer<'de>,
1424        {
1425            #[allow(non_camel_case_types)]
1426            #[doc(hidden)]
1427            enum __Field {
1428                __field0,
1429                __field1,
1430                __field2,
1431                __field3,
1432            }
1433            #[doc(hidden)]
1434            struct __FieldVisitor;
1435            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1436                type Value = __Field;
1437                fn expecting(
1438                    &self,
1439                    __formatter: &mut _serde::__private::Formatter,
1440                ) -> _serde::__private::fmt::Result {
1441                    _serde::__private::Formatter::write_str(
1442                        __formatter,
1443                        "variant identifier",
1444                    )
1445                }
1446                fn visit_int8<__E>(
1447                    self,
1448                    __value: i8,
1449                ) -> _serde::__private::Result<Self::Value, __E>
1450                where
1451                    __E: _serde::de::Error,
1452                {
1453                    match __value {
1454                        0i8 => _serde::__private::Ok(__Field::__field0),
1455                        1i8 => _serde::__private::Ok(__Field::__field1),
1456                        2i8 => _serde::__private::Ok(__Field::__field2),
1457                        3i8 => _serde::__private::Ok(__Field::__field3),
1458                        _ => {
1459                            _serde::__private::Err(
1460                                _serde::de::Error::invalid_value(
1461                                    _serde::de::Unexpected::Int8(__value),
1462                                    &"value(i8) of variant is one of 0, 1, 2, 3",
1463                                ),
1464                            )
1465                        }
1466                    }
1467                }
1468                fn visit_stringptr<__E>(
1469                    self,
1470                    __value: StringPtr<'de>,
1471                ) -> _serde::__private::Result<Self::Value, __E>
1472                where
1473                    __E: _serde::de::Error,
1474                {
1475                    if let Some(__value) = __value.into_inner() {
1476                        match __value.as_ref() {
1477                            v if v == "0" || v.eq_ignore_ascii_case("STATE_INACTIVE") => {
1478                                _serde::__private::Ok(__Field::__field0)
1479                            }
1480                            v if v == "1"
1481                                || v
1482                                    .eq_ignore_ascii_case("STATE_READY_FOR_SET_LOCAL_TIME") => {
1483                                _serde::__private::Ok(__Field::__field1)
1484                            }
1485                            v if v == "2"
1486                                || v
1487                                    .eq_ignore_ascii_case(
1488                                        "STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE",
1489                                    ) => _serde::__private::Ok(__Field::__field2),
1490                            v if v == "3" || v.eq_ignore_ascii_case("STATE_ACTIVE") => {
1491                                _serde::__private::Ok(__Field::__field3)
1492                            }
1493                            _ => {
1494                                _serde::__private::Err(
1495                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1496                                )
1497                            }
1498                        }
1499                    } else {
1500                        _serde::__private::Err(
1501                            _serde::de::Error::unknown_variant("None", VARIANTS),
1502                        )
1503                    }
1504                }
1505            }
1506            impl<'de> _serde::Deserialize<'de> for __Field {
1507                #[inline]
1508                fn deserialize<__D>(
1509                    __deserializer: __D,
1510                ) -> _serde::__private::Result<Self, __D::Error>
1511                where
1512                    __D: _serde::Deserializer<'de>,
1513                {
1514                    _serde::Deserializer::deserialize_identifier(
1515                        __deserializer,
1516                        _serde::de::ReadEnumSize::Int8,
1517                        __FieldVisitor,
1518                    )
1519                }
1520            }
1521            #[doc(hidden)]
1522            struct __Visitor<'de> {
1523                marker: _serde::__private::PhantomData<ToGeneratorState>,
1524                lifetime: _serde::__private::PhantomData<&'de ()>,
1525            }
1526            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1527                type Value = ToGeneratorState;
1528                fn expecting(
1529                    &self,
1530                    __formatter: &mut _serde::__private::Formatter,
1531                ) -> _serde::__private::fmt::Result {
1532                    _serde::__private::Formatter::write_str(
1533                        __formatter,
1534                        "enum ToGeneratorState",
1535                    )
1536                }
1537                fn visit_enum<__A>(
1538                    self,
1539                    __data: __A,
1540                ) -> _serde::__private::Result<Self::Value, __A::Error>
1541                where
1542                    __A: _serde::de::EnumAccess<'de>,
1543                {
1544                    match _serde::de::EnumAccess::variant(__data)? {
1545                        (__Field::__field0, __variant) => {
1546                            _serde::de::VariantAccess::unit_variant(__variant)?;
1547                            _serde::__private::Ok(ToGeneratorState::STATE_INACTIVE)
1548                        }
1549                        (__Field::__field1, __variant) => {
1550                            _serde::de::VariantAccess::unit_variant(__variant)?;
1551                            _serde::__private::Ok(
1552                                ToGeneratorState::STATE_READY_FOR_SET_LOCAL_TIME,
1553                            )
1554                        }
1555                        (__Field::__field2, __variant) => {
1556                            _serde::de::VariantAccess::unit_variant(__variant)?;
1557                            _serde::__private::Ok(
1558                                ToGeneratorState::STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE,
1559                            )
1560                        }
1561                        (__Field::__field3, __variant) => {
1562                            _serde::de::VariantAccess::unit_variant(__variant)?;
1563                            _serde::__private::Ok(ToGeneratorState::STATE_ACTIVE)
1564                        }
1565                    }
1566                }
1567            }
1568            #[doc(hidden)]
1569            const VARIANTS: &'static [&'static str] = &[
1570                "STATE_INACTIVE",
1571                "STATE_READY_FOR_SET_LOCAL_TIME",
1572                "STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE",
1573                "STATE_ACTIVE",
1574            ];
1575            _serde::Deserializer::deserialize_enum(
1576                __deserializer,
1577                "ToGeneratorState",
1578                VARIANTS,
1579                __Visitor {
1580                    marker: _serde::__private::PhantomData::<ToGeneratorState>,
1581                    lifetime: _serde::__private::PhantomData,
1582                },
1583            )
1584        }
1585    }
1586};
1587#[doc(hidden)]
1588#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1589const _: () = {
1590    #[allow(unused_extern_crates, clippy::useless_attribute)]
1591    extern crate havok_serde as _serde;
1592    #[automatically_derived]
1593    impl<'de> _serde::Deserialize<'de> for Stage {
1594        fn deserialize<__D>(
1595            __deserializer: __D,
1596        ) -> _serde::__private::Result<Self, __D::Error>
1597        where
1598            __D: _serde::Deserializer<'de>,
1599        {
1600            #[allow(non_camel_case_types)]
1601            #[doc(hidden)]
1602            enum __Field {
1603                __field0,
1604                __field1,
1605                __field2,
1606            }
1607            #[doc(hidden)]
1608            struct __FieldVisitor;
1609            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1610                type Value = __Field;
1611                fn expecting(
1612                    &self,
1613                    __formatter: &mut _serde::__private::Formatter,
1614                ) -> _serde::__private::fmt::Result {
1615                    _serde::__private::Formatter::write_str(
1616                        __formatter,
1617                        "variant identifier",
1618                    )
1619                }
1620                fn visit_int8<__E>(
1621                    self,
1622                    __value: i8,
1623                ) -> _serde::__private::Result<Self::Value, __E>
1624                where
1625                    __E: _serde::de::Error,
1626                {
1627                    match __value {
1628                        0i8 => _serde::__private::Ok(__Field::__field0),
1629                        1i8 => _serde::__private::Ok(__Field::__field1),
1630                        2i8 => _serde::__private::Ok(__Field::__field2),
1631                        _ => {
1632                            _serde::__private::Err(
1633                                _serde::de::Error::invalid_value(
1634                                    _serde::de::Unexpected::Int8(__value),
1635                                    &"value(i8) of variant is one of 0, 1, 2",
1636                                ),
1637                            )
1638                        }
1639                    }
1640                }
1641                fn visit_stringptr<__E>(
1642                    self,
1643                    __value: StringPtr<'de>,
1644                ) -> _serde::__private::Result<Self::Value, __E>
1645                where
1646                    __E: _serde::de::Error,
1647                {
1648                    if let Some(__value) = __value.into_inner() {
1649                        match __value.as_ref() {
1650                            v if v == "0"
1651                                || v.eq_ignore_ascii_case("STAGE_BLENDING_IN") => {
1652                                _serde::__private::Ok(__Field::__field0)
1653                            }
1654                            v if v == "1"
1655                                || v
1656                                    .eq_ignore_ascii_case(
1657                                        "STAGE_PLAYING_TRANSITION_GENERATOR",
1658                                    ) => _serde::__private::Ok(__Field::__field1),
1659                            v if v == "2"
1660                                || v.eq_ignore_ascii_case("STAGE_BLENDING_OUT") => {
1661                                _serde::__private::Ok(__Field::__field2)
1662                            }
1663                            _ => {
1664                                _serde::__private::Err(
1665                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1666                                )
1667                            }
1668                        }
1669                    } else {
1670                        _serde::__private::Err(
1671                            _serde::de::Error::unknown_variant("None", VARIANTS),
1672                        )
1673                    }
1674                }
1675            }
1676            impl<'de> _serde::Deserialize<'de> for __Field {
1677                #[inline]
1678                fn deserialize<__D>(
1679                    __deserializer: __D,
1680                ) -> _serde::__private::Result<Self, __D::Error>
1681                where
1682                    __D: _serde::Deserializer<'de>,
1683                {
1684                    _serde::Deserializer::deserialize_identifier(
1685                        __deserializer,
1686                        _serde::de::ReadEnumSize::Int8,
1687                        __FieldVisitor,
1688                    )
1689                }
1690            }
1691            #[doc(hidden)]
1692            struct __Visitor<'de> {
1693                marker: _serde::__private::PhantomData<Stage>,
1694                lifetime: _serde::__private::PhantomData<&'de ()>,
1695            }
1696            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1697                type Value = Stage;
1698                fn expecting(
1699                    &self,
1700                    __formatter: &mut _serde::__private::Formatter,
1701                ) -> _serde::__private::fmt::Result {
1702                    _serde::__private::Formatter::write_str(__formatter, "enum Stage")
1703                }
1704                fn visit_enum<__A>(
1705                    self,
1706                    __data: __A,
1707                ) -> _serde::__private::Result<Self::Value, __A::Error>
1708                where
1709                    __A: _serde::de::EnumAccess<'de>,
1710                {
1711                    match _serde::de::EnumAccess::variant(__data)? {
1712                        (__Field::__field0, __variant) => {
1713                            _serde::de::VariantAccess::unit_variant(__variant)?;
1714                            _serde::__private::Ok(Stage::STAGE_BLENDING_IN)
1715                        }
1716                        (__Field::__field1, __variant) => {
1717                            _serde::de::VariantAccess::unit_variant(__variant)?;
1718                            _serde::__private::Ok(
1719                                Stage::STAGE_PLAYING_TRANSITION_GENERATOR,
1720                            )
1721                        }
1722                        (__Field::__field2, __variant) => {
1723                            _serde::de::VariantAccess::unit_variant(__variant)?;
1724                            _serde::__private::Ok(Stage::STAGE_BLENDING_OUT)
1725                        }
1726                    }
1727                }
1728            }
1729            #[doc(hidden)]
1730            const VARIANTS: &'static [&'static str] = &[
1731                "STAGE_BLENDING_IN",
1732                "STAGE_PLAYING_TRANSITION_GENERATOR",
1733                "STAGE_BLENDING_OUT",
1734            ];
1735            _serde::Deserializer::deserialize_enum(
1736                __deserializer,
1737                "Stage",
1738                VARIANTS,
1739                __Visitor {
1740                    marker: _serde::__private::PhantomData::<Stage>,
1741                    lifetime: _serde::__private::PhantomData,
1742                },
1743            )
1744        }
1745    }
1746};