havok_classes/generated/
hkpKeyframedRigidMotion_.rs

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