1use super::class_requires::*;
2use super::*;
3#[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 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[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 #[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};