havok_classes/generated/
hkbTransitionEffect_.rs

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