havok_classes/generated/
hkpFixedRigidMotion_.rs

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