havok_classes/generated/
hkpBoxMotion_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpBoxMotion`
5/// - version: `0`
6/// - signature: `0xbafa2bb7`
7/// - size: `288`(x86)/`320`(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 hkpBoxMotion {
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    pub parent: hkpMotion,
30}
31const _: () = {
32    use havok_serde as _serde;
33    impl _serde::HavokClass for hkpBoxMotion {
34        #[inline]
35        fn name(&self) -> &'static str {
36            "hkpBoxMotion"
37        }
38        #[inline]
39        fn signature(&self) -> _serde::__private::Signature {
40            _serde::__private::Signature::new(0xbafa2bb7)
41        }
42        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
43        fn deps_indexes(&self) -> Vec<usize> {
44            let mut v = Vec::new();
45            v.extend(self.parent.m_motionState.deps_indexes());
46            v.push(self.parent.m_savedMotion.get());
47            v
48        }
49    }
50    impl _serde::Serialize for hkpBoxMotion {
51        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
52        where
53            S: _serde::ser::Serializer,
54        {
55            let class_meta = self
56                .__ptr
57                .map(|name| (name, _serde::__private::Signature::new(0xbafa2bb7)));
58            let mut serializer = __serializer
59                .serialize_struct("hkpBoxMotion", class_meta, (288u64, 320u64))?;
60            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
61            serializer
62                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
63            serializer
64                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
65            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
66            serializer.serialize_field("type", &self.parent.m_type)?;
67            serializer
68                .serialize_field(
69                    "deactivationIntegrateCounter",
70                    &self.parent.m_deactivationIntegrateCounter,
71                )?;
72            serializer
73                .serialize_fixed_array_field(
74                    "deactivationNumInactiveFrames",
75                    self.parent.m_deactivationNumInactiveFrames.as_slice(),
76                    TypeSize::NonPtr,
77                )?;
78            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 10usize].as_slice())?;
79            serializer.serialize_field("motionState", &self.parent.m_motionState)?;
80            serializer
81                .serialize_field("inertiaAndMassInv", &self.parent.m_inertiaAndMassInv)?;
82            serializer.serialize_field("linearVelocity", &self.parent.m_linearVelocity)?;
83            serializer
84                .serialize_field("angularVelocity", &self.parent.m_angularVelocity)?;
85            serializer
86                .serialize_fixed_array_field(
87                    "deactivationRefPosition",
88                    self.parent.m_deactivationRefPosition.as_slice(),
89                    TypeSize::NonPtr,
90                )?;
91            serializer
92                .serialize_fixed_array_field(
93                    "deactivationRefOrientation",
94                    self.parent.m_deactivationRefOrientation.as_slice(),
95                    TypeSize::NonPtr,
96                )?;
97            serializer.serialize_field("savedMotion", &self.parent.m_savedMotion)?;
98            serializer
99                .serialize_field(
100                    "savedQualityTypeIndex",
101                    &self.parent.m_savedQualityTypeIndex,
102                )?;
103            serializer.serialize_field("gravityFactor", &self.parent.m_gravityFactor)?;
104            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 12usize].as_slice())?;
105            serializer.end()
106        }
107    }
108};
109#[doc(hidden)]
110#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
111const _: () = {
112    use havok_serde as _serde;
113    #[automatically_derived]
114    impl<'de> _serde::Deserialize<'de> for hkpBoxMotion {
115        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
116        where
117            __D: _serde::Deserializer<'de>,
118        {
119            #[allow(non_camel_case_types)]
120            enum __Field {
121                m_type,
122                m_deactivationIntegrateCounter,
123                m_deactivationNumInactiveFrames,
124                m_motionState,
125                m_inertiaAndMassInv,
126                m_linearVelocity,
127                m_angularVelocity,
128                m_deactivationRefPosition,
129                m_deactivationRefOrientation,
130                m_savedMotion,
131                m_savedQualityTypeIndex,
132                m_gravityFactor,
133                __ignore,
134            }
135            struct __FieldVisitor;
136            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
137                type Value = __Field;
138                fn expecting(
139                    &self,
140                    __formatter: &mut core::fmt::Formatter,
141                ) -> core::fmt::Result {
142                    core::fmt::Formatter::write_str(__formatter, "field identifier")
143                }
144                /// Intended for use in XML.
145                #[allow(clippy::match_single_binding)]
146                #[allow(clippy::reversed_empty_ranges)]
147                #[allow(clippy::single_match)]
148                fn visit_key<__E>(
149                    self,
150                    __value: &str,
151                ) -> core::result::Result<Self::Value, __E>
152                where
153                    __E: _serde::de::Error,
154                {
155                    match __value {
156                        "type" => Ok(__Field::m_type),
157                        "deactivationIntegrateCounter" => {
158                            Ok(__Field::m_deactivationIntegrateCounter)
159                        }
160                        "deactivationNumInactiveFrames" => {
161                            Ok(__Field::m_deactivationNumInactiveFrames)
162                        }
163                        "motionState" => Ok(__Field::m_motionState),
164                        "inertiaAndMassInv" => Ok(__Field::m_inertiaAndMassInv),
165                        "linearVelocity" => Ok(__Field::m_linearVelocity),
166                        "angularVelocity" => Ok(__Field::m_angularVelocity),
167                        "deactivationRefPosition" => {
168                            Ok(__Field::m_deactivationRefPosition)
169                        }
170                        "deactivationRefOrientation" => {
171                            Ok(__Field::m_deactivationRefOrientation)
172                        }
173                        "savedMotion" => Ok(__Field::m_savedMotion),
174                        "savedQualityTypeIndex" => Ok(__Field::m_savedQualityTypeIndex),
175                        "gravityFactor" => Ok(__Field::m_gravityFactor),
176                        _ => Ok(__Field::__ignore),
177                    }
178                }
179            }
180            impl<'de> _serde::Deserialize<'de> for __Field {
181                #[inline]
182                fn deserialize<__D>(
183                    __deserializer: __D,
184                ) -> core::result::Result<Self, __D::Error>
185                where
186                    __D: _serde::Deserializer<'de>,
187                {
188                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
189                }
190            }
191            struct __hkpBoxMotionVisitor<'de> {
192                marker: _serde::__private::PhantomData<hkpBoxMotion>,
193                lifetime: _serde::__private::PhantomData<&'de ()>,
194            }
195            #[allow(clippy::match_single_binding)]
196            #[allow(clippy::reversed_empty_ranges)]
197            #[allow(clippy::single_match)]
198            impl<'de> _serde::de::Visitor<'de> for __hkpBoxMotionVisitor<'de> {
199                type Value = hkpBoxMotion;
200                fn expecting(
201                    &self,
202                    __formatter: &mut core::fmt::Formatter,
203                ) -> core::fmt::Result {
204                    core::fmt::Formatter::write_str(__formatter, "struct hkpBoxMotion")
205                }
206                fn visit_struct_for_bytes<__A>(
207                    self,
208                    mut __map: __A,
209                ) -> _serde::__private::Result<Self::Value, __A::Error>
210                where
211                    __A: _serde::de::MapAccess<'de>,
212                {
213                    let __ptr = __A::class_ptr(&mut __map);
214                    let parent = __A::parent_value(&mut __map)?;
215                    for i in 0..0usize {
216                        match i {
217                            _ => {}
218                        }
219                    }
220                    _serde::__private::Ok(hkpBoxMotion { __ptr, parent })
221                }
222                #[allow(clippy::manual_unwrap_or_default)]
223                fn visit_struct<__A>(
224                    self,
225                    mut __map: __A,
226                ) -> _serde::__private::Result<Self::Value, __A::Error>
227                where
228                    __A: _serde::de::MapAccess<'de>,
229                {
230                    let mut m_type: _serde::__private::Option<MotionType> = _serde::__private::None;
231                    let mut m_deactivationIntegrateCounter: _serde::__private::Option<
232                        u8,
233                    > = _serde::__private::None;
234                    let mut m_deactivationNumInactiveFrames: _serde::__private::Option<
235                        [u16; 2usize],
236                    > = _serde::__private::None;
237                    let mut m_motionState: _serde::__private::Option<hkMotionState> = _serde::__private::None;
238                    let mut m_inertiaAndMassInv: _serde::__private::Option<Vector4> = _serde::__private::None;
239                    let mut m_linearVelocity: _serde::__private::Option<Vector4> = _serde::__private::None;
240                    let mut m_angularVelocity: _serde::__private::Option<Vector4> = _serde::__private::None;
241                    let mut m_deactivationRefPosition: _serde::__private::Option<
242                        [Vector4; 2usize],
243                    > = _serde::__private::None;
244                    let mut m_deactivationRefOrientation: _serde::__private::Option<
245                        [u32; 2usize],
246                    > = _serde::__private::None;
247                    let mut m_savedMotion: _serde::__private::Option<Pointer> = _serde::__private::None;
248                    let mut m_savedQualityTypeIndex: _serde::__private::Option<u16> = _serde::__private::None;
249                    let mut m_gravityFactor: _serde::__private::Option<f16> = _serde::__private::None;
250                    while let _serde::__private::Some(__key) = {
251                        __A::next_key::<__Field>(&mut __map)?
252                    } {
253                        match __key {
254                            __Field::m_type => {
255                                #[cfg(
256                                    any(feature = "strict", feature = "ignore_duplicates")
257                                )]
258                                if _serde::__private::Option::is_some(&m_type) {
259                                    #[cfg(feature = "ignore_duplicates")]
260                                    {
261                                        __A::skip_value(&mut __map)?;
262                                        continue;
263                                    }
264                                    #[cfg(feature = "strict")]
265                                    return _serde::__private::Err(
266                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
267                                    );
268                                }
269                                m_type = _serde::__private::Some(
270                                    match __A::next_value::<MotionType>(&mut __map) {
271                                        _serde::__private::Ok(__val) => __val,
272                                        _serde::__private::Err(__err) => {
273                                            return _serde::__private::Err(__err);
274                                        }
275                                    },
276                                );
277                            }
278                            __Field::m_deactivationIntegrateCounter => {
279                                #[cfg(
280                                    any(feature = "strict", feature = "ignore_duplicates")
281                                )]
282                                if _serde::__private::Option::is_some(
283                                    &m_deactivationIntegrateCounter,
284                                ) {
285                                    #[cfg(feature = "ignore_duplicates")]
286                                    {
287                                        __A::skip_value(&mut __map)?;
288                                        continue;
289                                    }
290                                    #[cfg(feature = "strict")]
291                                    return _serde::__private::Err(
292                                        <__A::Error as _serde::de::Error>::duplicate_field(
293                                            "deactivationIntegrateCounter",
294                                        ),
295                                    );
296                                }
297                                m_deactivationIntegrateCounter = _serde::__private::Some(
298                                    match __A::next_value::<u8>(&mut __map) {
299                                        _serde::__private::Ok(__val) => __val,
300                                        _serde::__private::Err(__err) => {
301                                            return _serde::__private::Err(__err);
302                                        }
303                                    },
304                                );
305                            }
306                            __Field::m_deactivationNumInactiveFrames => {
307                                #[cfg(
308                                    any(feature = "strict", feature = "ignore_duplicates")
309                                )]
310                                if _serde::__private::Option::is_some(
311                                    &m_deactivationNumInactiveFrames,
312                                ) {
313                                    #[cfg(feature = "ignore_duplicates")]
314                                    {
315                                        __A::skip_value(&mut __map)?;
316                                        continue;
317                                    }
318                                    #[cfg(feature = "strict")]
319                                    return _serde::__private::Err(
320                                        <__A::Error as _serde::de::Error>::duplicate_field(
321                                            "deactivationNumInactiveFrames",
322                                        ),
323                                    );
324                                }
325                                m_deactivationNumInactiveFrames = _serde::__private::Some(
326                                    match __A::next_value::<[u16; 2usize]>(&mut __map) {
327                                        _serde::__private::Ok(__val) => __val,
328                                        _serde::__private::Err(__err) => {
329                                            return _serde::__private::Err(__err);
330                                        }
331                                    },
332                                );
333                            }
334                            __Field::m_motionState => {
335                                #[cfg(
336                                    any(feature = "strict", feature = "ignore_duplicates")
337                                )]
338                                if _serde::__private::Option::is_some(&m_motionState) {
339                                    #[cfg(feature = "ignore_duplicates")]
340                                    {
341                                        __A::skip_value(&mut __map)?;
342                                        continue;
343                                    }
344                                    #[cfg(feature = "strict")]
345                                    return _serde::__private::Err(
346                                        <__A::Error as _serde::de::Error>::duplicate_field(
347                                            "motionState",
348                                        ),
349                                    );
350                                }
351                                m_motionState = _serde::__private::Some(
352                                    match __A::next_value::<hkMotionState>(&mut __map) {
353                                        _serde::__private::Ok(__val) => __val,
354                                        _serde::__private::Err(__err) => {
355                                            return _serde::__private::Err(__err);
356                                        }
357                                    },
358                                );
359                            }
360                            __Field::m_inertiaAndMassInv => {
361                                #[cfg(
362                                    any(feature = "strict", feature = "ignore_duplicates")
363                                )]
364                                if _serde::__private::Option::is_some(
365                                    &m_inertiaAndMassInv,
366                                ) {
367                                    #[cfg(feature = "ignore_duplicates")]
368                                    {
369                                        __A::skip_value(&mut __map)?;
370                                        continue;
371                                    }
372                                    #[cfg(feature = "strict")]
373                                    return _serde::__private::Err(
374                                        <__A::Error as _serde::de::Error>::duplicate_field(
375                                            "inertiaAndMassInv",
376                                        ),
377                                    );
378                                }
379                                m_inertiaAndMassInv = _serde::__private::Some(
380                                    match __A::next_value::<Vector4>(&mut __map) {
381                                        _serde::__private::Ok(__val) => __val,
382                                        _serde::__private::Err(__err) => {
383                                            return _serde::__private::Err(__err);
384                                        }
385                                    },
386                                );
387                            }
388                            __Field::m_linearVelocity => {
389                                #[cfg(
390                                    any(feature = "strict", feature = "ignore_duplicates")
391                                )]
392                                if _serde::__private::Option::is_some(&m_linearVelocity) {
393                                    #[cfg(feature = "ignore_duplicates")]
394                                    {
395                                        __A::skip_value(&mut __map)?;
396                                        continue;
397                                    }
398                                    #[cfg(feature = "strict")]
399                                    return _serde::__private::Err(
400                                        <__A::Error as _serde::de::Error>::duplicate_field(
401                                            "linearVelocity",
402                                        ),
403                                    );
404                                }
405                                m_linearVelocity = _serde::__private::Some(
406                                    match __A::next_value::<Vector4>(&mut __map) {
407                                        _serde::__private::Ok(__val) => __val,
408                                        _serde::__private::Err(__err) => {
409                                            return _serde::__private::Err(__err);
410                                        }
411                                    },
412                                );
413                            }
414                            __Field::m_angularVelocity => {
415                                #[cfg(
416                                    any(feature = "strict", feature = "ignore_duplicates")
417                                )]
418                                if _serde::__private::Option::is_some(&m_angularVelocity) {
419                                    #[cfg(feature = "ignore_duplicates")]
420                                    {
421                                        __A::skip_value(&mut __map)?;
422                                        continue;
423                                    }
424                                    #[cfg(feature = "strict")]
425                                    return _serde::__private::Err(
426                                        <__A::Error as _serde::de::Error>::duplicate_field(
427                                            "angularVelocity",
428                                        ),
429                                    );
430                                }
431                                m_angularVelocity = _serde::__private::Some(
432                                    match __A::next_value::<Vector4>(&mut __map) {
433                                        _serde::__private::Ok(__val) => __val,
434                                        _serde::__private::Err(__err) => {
435                                            return _serde::__private::Err(__err);
436                                        }
437                                    },
438                                );
439                            }
440                            __Field::m_deactivationRefPosition => {
441                                #[cfg(
442                                    any(feature = "strict", feature = "ignore_duplicates")
443                                )]
444                                if _serde::__private::Option::is_some(
445                                    &m_deactivationRefPosition,
446                                ) {
447                                    #[cfg(feature = "ignore_duplicates")]
448                                    {
449                                        __A::skip_value(&mut __map)?;
450                                        continue;
451                                    }
452                                    #[cfg(feature = "strict")]
453                                    return _serde::__private::Err(
454                                        <__A::Error as _serde::de::Error>::duplicate_field(
455                                            "deactivationRefPosition",
456                                        ),
457                                    );
458                                }
459                                m_deactivationRefPosition = _serde::__private::Some(
460                                    match __A::next_value::<[Vector4; 2usize]>(&mut __map) {
461                                        _serde::__private::Ok(__val) => __val,
462                                        _serde::__private::Err(__err) => {
463                                            return _serde::__private::Err(__err);
464                                        }
465                                    },
466                                );
467                            }
468                            __Field::m_deactivationRefOrientation => {
469                                #[cfg(
470                                    any(feature = "strict", feature = "ignore_duplicates")
471                                )]
472                                if _serde::__private::Option::is_some(
473                                    &m_deactivationRefOrientation,
474                                ) {
475                                    #[cfg(feature = "ignore_duplicates")]
476                                    {
477                                        __A::skip_value(&mut __map)?;
478                                        continue;
479                                    }
480                                    #[cfg(feature = "strict")]
481                                    return _serde::__private::Err(
482                                        <__A::Error as _serde::de::Error>::duplicate_field(
483                                            "deactivationRefOrientation",
484                                        ),
485                                    );
486                                }
487                                m_deactivationRefOrientation = _serde::__private::Some(
488                                    match __A::next_value::<[u32; 2usize]>(&mut __map) {
489                                        _serde::__private::Ok(__val) => __val,
490                                        _serde::__private::Err(__err) => {
491                                            return _serde::__private::Err(__err);
492                                        }
493                                    },
494                                );
495                            }
496                            __Field::m_savedMotion => {
497                                #[cfg(
498                                    any(feature = "strict", feature = "ignore_duplicates")
499                                )]
500                                if _serde::__private::Option::is_some(&m_savedMotion) {
501                                    #[cfg(feature = "ignore_duplicates")]
502                                    {
503                                        __A::skip_value(&mut __map)?;
504                                        continue;
505                                    }
506                                    #[cfg(feature = "strict")]
507                                    return _serde::__private::Err(
508                                        <__A::Error as _serde::de::Error>::duplicate_field(
509                                            "savedMotion",
510                                        ),
511                                    );
512                                }
513                                m_savedMotion = _serde::__private::Some(
514                                    match __A::next_value::<Pointer>(&mut __map) {
515                                        _serde::__private::Ok(__val) => __val,
516                                        _serde::__private::Err(__err) => {
517                                            return _serde::__private::Err(__err);
518                                        }
519                                    },
520                                );
521                            }
522                            __Field::m_savedQualityTypeIndex => {
523                                #[cfg(
524                                    any(feature = "strict", feature = "ignore_duplicates")
525                                )]
526                                if _serde::__private::Option::is_some(
527                                    &m_savedQualityTypeIndex,
528                                ) {
529                                    #[cfg(feature = "ignore_duplicates")]
530                                    {
531                                        __A::skip_value(&mut __map)?;
532                                        continue;
533                                    }
534                                    #[cfg(feature = "strict")]
535                                    return _serde::__private::Err(
536                                        <__A::Error as _serde::de::Error>::duplicate_field(
537                                            "savedQualityTypeIndex",
538                                        ),
539                                    );
540                                }
541                                m_savedQualityTypeIndex = _serde::__private::Some(
542                                    match __A::next_value::<u16>(&mut __map) {
543                                        _serde::__private::Ok(__val) => __val,
544                                        _serde::__private::Err(__err) => {
545                                            return _serde::__private::Err(__err);
546                                        }
547                                    },
548                                );
549                            }
550                            __Field::m_gravityFactor => {
551                                #[cfg(
552                                    any(feature = "strict", feature = "ignore_duplicates")
553                                )]
554                                if _serde::__private::Option::is_some(&m_gravityFactor) {
555                                    #[cfg(feature = "ignore_duplicates")]
556                                    {
557                                        __A::skip_value(&mut __map)?;
558                                        continue;
559                                    }
560                                    #[cfg(feature = "strict")]
561                                    return _serde::__private::Err(
562                                        <__A::Error as _serde::de::Error>::duplicate_field(
563                                            "gravityFactor",
564                                        ),
565                                    );
566                                }
567                                m_gravityFactor = _serde::__private::Some(
568                                    match __A::next_value::<f16>(&mut __map) {
569                                        _serde::__private::Ok(__val) => __val,
570                                        _serde::__private::Err(__err) => {
571                                            return _serde::__private::Err(__err);
572                                        }
573                                    },
574                                );
575                            }
576                            _ => __A::skip_value(&mut __map)?,
577                        }
578                    }
579                    let m_type = match m_type {
580                        _serde::__private::Some(__field) => __field,
581                        _serde::__private::None => {
582                            #[cfg(feature = "strict")]
583                            return _serde::__private::Err(
584                                <__A::Error as _serde::de::Error>::missing_field("type"),
585                            );
586                            #[cfg(not(feature = "strict"))] Default::default()
587                        }
588                    };
589                    let m_deactivationIntegrateCounter = match m_deactivationIntegrateCounter {
590                        _serde::__private::Some(__field) => __field,
591                        _serde::__private::None => {
592                            #[cfg(feature = "strict")]
593                            return _serde::__private::Err(
594                                <__A::Error as _serde::de::Error>::missing_field(
595                                    "deactivationIntegrateCounter",
596                                ),
597                            );
598                            #[cfg(not(feature = "strict"))] Default::default()
599                        }
600                    };
601                    let m_deactivationNumInactiveFrames = match m_deactivationNumInactiveFrames {
602                        _serde::__private::Some(__field) => __field,
603                        _serde::__private::None => {
604                            #[cfg(feature = "strict")]
605                            return _serde::__private::Err(
606                                <__A::Error as _serde::de::Error>::missing_field(
607                                    "deactivationNumInactiveFrames",
608                                ),
609                            );
610                            #[cfg(not(feature = "strict"))] Default::default()
611                        }
612                    };
613                    let m_motionState = match m_motionState {
614                        _serde::__private::Some(__field) => __field,
615                        _serde::__private::None => {
616                            #[cfg(feature = "strict")]
617                            return _serde::__private::Err(
618                                <__A::Error as _serde::de::Error>::missing_field(
619                                    "motionState",
620                                ),
621                            );
622                            #[cfg(not(feature = "strict"))] Default::default()
623                        }
624                    };
625                    let m_inertiaAndMassInv = match m_inertiaAndMassInv {
626                        _serde::__private::Some(__field) => __field,
627                        _serde::__private::None => {
628                            #[cfg(feature = "strict")]
629                            return _serde::__private::Err(
630                                <__A::Error as _serde::de::Error>::missing_field(
631                                    "inertiaAndMassInv",
632                                ),
633                            );
634                            #[cfg(not(feature = "strict"))] Default::default()
635                        }
636                    };
637                    let m_linearVelocity = match m_linearVelocity {
638                        _serde::__private::Some(__field) => __field,
639                        _serde::__private::None => {
640                            #[cfg(feature = "strict")]
641                            return _serde::__private::Err(
642                                <__A::Error as _serde::de::Error>::missing_field(
643                                    "linearVelocity",
644                                ),
645                            );
646                            #[cfg(not(feature = "strict"))] Default::default()
647                        }
648                    };
649                    let m_angularVelocity = match m_angularVelocity {
650                        _serde::__private::Some(__field) => __field,
651                        _serde::__private::None => {
652                            #[cfg(feature = "strict")]
653                            return _serde::__private::Err(
654                                <__A::Error as _serde::de::Error>::missing_field(
655                                    "angularVelocity",
656                                ),
657                            );
658                            #[cfg(not(feature = "strict"))] Default::default()
659                        }
660                    };
661                    let m_deactivationRefPosition = match m_deactivationRefPosition {
662                        _serde::__private::Some(__field) => __field,
663                        _serde::__private::None => {
664                            #[cfg(feature = "strict")]
665                            return _serde::__private::Err(
666                                <__A::Error as _serde::de::Error>::missing_field(
667                                    "deactivationRefPosition",
668                                ),
669                            );
670                            #[cfg(not(feature = "strict"))] Default::default()
671                        }
672                    };
673                    let m_deactivationRefOrientation = match m_deactivationRefOrientation {
674                        _serde::__private::Some(__field) => __field,
675                        _serde::__private::None => {
676                            #[cfg(feature = "strict")]
677                            return _serde::__private::Err(
678                                <__A::Error as _serde::de::Error>::missing_field(
679                                    "deactivationRefOrientation",
680                                ),
681                            );
682                            #[cfg(not(feature = "strict"))] Default::default()
683                        }
684                    };
685                    let m_savedMotion = match m_savedMotion {
686                        _serde::__private::Some(__field) => __field,
687                        _serde::__private::None => {
688                            #[cfg(feature = "strict")]
689                            return _serde::__private::Err(
690                                <__A::Error as _serde::de::Error>::missing_field(
691                                    "savedMotion",
692                                ),
693                            );
694                            #[cfg(not(feature = "strict"))] Default::default()
695                        }
696                    };
697                    let m_savedQualityTypeIndex = match m_savedQualityTypeIndex {
698                        _serde::__private::Some(__field) => __field,
699                        _serde::__private::None => {
700                            #[cfg(feature = "strict")]
701                            return _serde::__private::Err(
702                                <__A::Error as _serde::de::Error>::missing_field(
703                                    "savedQualityTypeIndex",
704                                ),
705                            );
706                            #[cfg(not(feature = "strict"))] Default::default()
707                        }
708                    };
709                    let m_gravityFactor = match m_gravityFactor {
710                        _serde::__private::Some(__field) => __field,
711                        _serde::__private::None => {
712                            #[cfg(feature = "strict")]
713                            return _serde::__private::Err(
714                                <__A::Error as _serde::de::Error>::missing_field(
715                                    "gravityFactor",
716                                ),
717                            );
718                            #[cfg(not(feature = "strict"))] Default::default()
719                        }
720                    };
721                    let __ptr = None;
722                    let parent = hkBaseObject { __ptr };
723                    let parent = hkReferencedObject {
724                        __ptr,
725                        parent,
726                        ..Default::default()
727                    };
728                    let parent = hkpMotion {
729                        __ptr,
730                        parent,
731                        m_type,
732                        m_deactivationIntegrateCounter,
733                        m_deactivationNumInactiveFrames,
734                        m_motionState,
735                        m_inertiaAndMassInv,
736                        m_linearVelocity,
737                        m_angularVelocity,
738                        m_deactivationRefPosition,
739                        m_deactivationRefOrientation,
740                        m_savedMotion,
741                        m_savedQualityTypeIndex,
742                        m_gravityFactor,
743                    };
744                    let __ptr = __A::class_ptr(&mut __map);
745                    _serde::__private::Ok(hkpBoxMotion { __ptr, parent })
746                }
747            }
748            const FIELDS: &[&str] = &[];
749            _serde::Deserializer::deserialize_struct(
750                deserializer,
751                "hkpBoxMotion",
752                FIELDS,
753                __hkpBoxMotionVisitor {
754                    marker: _serde::__private::PhantomData::<hkpBoxMotion>,
755                    lifetime: _serde::__private::PhantomData,
756                },
757            )
758        }
759    }
760};