havok_classes/generated/
hkbBlendingTransitionEffect_.rs

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