havok_classes/generated/
hkbGetUpModifier_.rs

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