havok_classes/generated/
BSCyclicBlendTransitionGenerator_.rs

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