havok_classes/generated/
BGSGamebryoSequenceGenerator_.rs

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