havok_classes/generated/
hkbCharacterControllerModifier_.rs

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