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 hkpKeyframedRigidMotion {
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: 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 #[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};