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 hkpThinBoxMotion {
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: hkpBoxMotion,
30}
31const _: () = {
32 use havok_serde as _serde;
33 impl _serde::HavokClass for hkpThinBoxMotion {
34 #[inline]
35 fn name(&self) -> &'static str {
36 "hkpThinBoxMotion"
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 hkpThinBoxMotion {
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("hkpThinBoxMotion", 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 hkpThinBoxMotion {
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 __hkpThinBoxMotionVisitor<'de> {
211 marker: _serde::__private::PhantomData<hkpThinBoxMotion>,
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 __hkpThinBoxMotionVisitor<'de> {
218 type Value = hkpThinBoxMotion;
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 hkpThinBoxMotion",
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(hkpThinBoxMotion { __ptr, parent })
243 }
244 #[allow(clippy::manual_unwrap_or_default)]
245 fn visit_struct<__A>(
246 self,
247 mut __map: __A,
248 ) -> _serde::__private::Result<Self::Value, __A::Error>
249 where
250 __A: _serde::de::MapAccess<'de>,
251 {
252 let mut m_type: _serde::__private::Option<MotionType> = _serde::__private::None;
253 let mut m_deactivationIntegrateCounter: _serde::__private::Option<
254 u8,
255 > = _serde::__private::None;
256 let mut m_deactivationNumInactiveFrames: _serde::__private::Option<
257 [u16; 2usize],
258 > = _serde::__private::None;
259 let mut m_motionState: _serde::__private::Option<hkMotionState> = _serde::__private::None;
260 let mut m_inertiaAndMassInv: _serde::__private::Option<Vector4> = _serde::__private::None;
261 let mut m_linearVelocity: _serde::__private::Option<Vector4> = _serde::__private::None;
262 let mut m_angularVelocity: _serde::__private::Option<Vector4> = _serde::__private::None;
263 let mut m_deactivationRefPosition: _serde::__private::Option<
264 [Vector4; 2usize],
265 > = _serde::__private::None;
266 let mut m_deactivationRefOrientation: _serde::__private::Option<
267 [u32; 2usize],
268 > = _serde::__private::None;
269 let mut m_savedMotion: _serde::__private::Option<Pointer> = _serde::__private::None;
270 let mut m_savedQualityTypeIndex: _serde::__private::Option<u16> = _serde::__private::None;
271 let mut m_gravityFactor: _serde::__private::Option<f16> = _serde::__private::None;
272 while let _serde::__private::Some(__key) = {
273 __A::next_key::<__Field>(&mut __map)?
274 } {
275 match __key {
276 __Field::m_type => {
277 #[cfg(
278 any(feature = "strict", feature = "ignore_duplicates")
279 )]
280 if _serde::__private::Option::is_some(&m_type) {
281 #[cfg(feature = "ignore_duplicates")]
282 {
283 __A::skip_value(&mut __map)?;
284 continue;
285 }
286 #[cfg(feature = "strict")]
287 return _serde::__private::Err(
288 <__A::Error as _serde::de::Error>::duplicate_field("type"),
289 );
290 }
291 m_type = _serde::__private::Some(
292 match __A::next_value::<MotionType>(&mut __map) {
293 _serde::__private::Ok(__val) => __val,
294 _serde::__private::Err(__err) => {
295 return _serde::__private::Err(__err);
296 }
297 },
298 );
299 }
300 __Field::m_deactivationIntegrateCounter => {
301 #[cfg(
302 any(feature = "strict", feature = "ignore_duplicates")
303 )]
304 if _serde::__private::Option::is_some(
305 &m_deactivationIntegrateCounter,
306 ) {
307 #[cfg(feature = "ignore_duplicates")]
308 {
309 __A::skip_value(&mut __map)?;
310 continue;
311 }
312 #[cfg(feature = "strict")]
313 return _serde::__private::Err(
314 <__A::Error as _serde::de::Error>::duplicate_field(
315 "deactivationIntegrateCounter",
316 ),
317 );
318 }
319 m_deactivationIntegrateCounter = _serde::__private::Some(
320 match __A::next_value::<u8>(&mut __map) {
321 _serde::__private::Ok(__val) => __val,
322 _serde::__private::Err(__err) => {
323 return _serde::__private::Err(__err);
324 }
325 },
326 );
327 }
328 __Field::m_deactivationNumInactiveFrames => {
329 #[cfg(
330 any(feature = "strict", feature = "ignore_duplicates")
331 )]
332 if _serde::__private::Option::is_some(
333 &m_deactivationNumInactiveFrames,
334 ) {
335 #[cfg(feature = "ignore_duplicates")]
336 {
337 __A::skip_value(&mut __map)?;
338 continue;
339 }
340 #[cfg(feature = "strict")]
341 return _serde::__private::Err(
342 <__A::Error as _serde::de::Error>::duplicate_field(
343 "deactivationNumInactiveFrames",
344 ),
345 );
346 }
347 m_deactivationNumInactiveFrames = _serde::__private::Some(
348 match __A::next_value::<[u16; 2usize]>(&mut __map) {
349 _serde::__private::Ok(__val) => __val,
350 _serde::__private::Err(__err) => {
351 return _serde::__private::Err(__err);
352 }
353 },
354 );
355 }
356 __Field::m_motionState => {
357 #[cfg(
358 any(feature = "strict", feature = "ignore_duplicates")
359 )]
360 if _serde::__private::Option::is_some(&m_motionState) {
361 #[cfg(feature = "ignore_duplicates")]
362 {
363 __A::skip_value(&mut __map)?;
364 continue;
365 }
366 #[cfg(feature = "strict")]
367 return _serde::__private::Err(
368 <__A::Error as _serde::de::Error>::duplicate_field(
369 "motionState",
370 ),
371 );
372 }
373 m_motionState = _serde::__private::Some(
374 match __A::next_value::<hkMotionState>(&mut __map) {
375 _serde::__private::Ok(__val) => __val,
376 _serde::__private::Err(__err) => {
377 return _serde::__private::Err(__err);
378 }
379 },
380 );
381 }
382 __Field::m_inertiaAndMassInv => {
383 #[cfg(
384 any(feature = "strict", feature = "ignore_duplicates")
385 )]
386 if _serde::__private::Option::is_some(
387 &m_inertiaAndMassInv,
388 ) {
389 #[cfg(feature = "ignore_duplicates")]
390 {
391 __A::skip_value(&mut __map)?;
392 continue;
393 }
394 #[cfg(feature = "strict")]
395 return _serde::__private::Err(
396 <__A::Error as _serde::de::Error>::duplicate_field(
397 "inertiaAndMassInv",
398 ),
399 );
400 }
401 m_inertiaAndMassInv = _serde::__private::Some(
402 match __A::next_value::<Vector4>(&mut __map) {
403 _serde::__private::Ok(__val) => __val,
404 _serde::__private::Err(__err) => {
405 return _serde::__private::Err(__err);
406 }
407 },
408 );
409 }
410 __Field::m_linearVelocity => {
411 #[cfg(
412 any(feature = "strict", feature = "ignore_duplicates")
413 )]
414 if _serde::__private::Option::is_some(&m_linearVelocity) {
415 #[cfg(feature = "ignore_duplicates")]
416 {
417 __A::skip_value(&mut __map)?;
418 continue;
419 }
420 #[cfg(feature = "strict")]
421 return _serde::__private::Err(
422 <__A::Error as _serde::de::Error>::duplicate_field(
423 "linearVelocity",
424 ),
425 );
426 }
427 m_linearVelocity = _serde::__private::Some(
428 match __A::next_value::<Vector4>(&mut __map) {
429 _serde::__private::Ok(__val) => __val,
430 _serde::__private::Err(__err) => {
431 return _serde::__private::Err(__err);
432 }
433 },
434 );
435 }
436 __Field::m_angularVelocity => {
437 #[cfg(
438 any(feature = "strict", feature = "ignore_duplicates")
439 )]
440 if _serde::__private::Option::is_some(&m_angularVelocity) {
441 #[cfg(feature = "ignore_duplicates")]
442 {
443 __A::skip_value(&mut __map)?;
444 continue;
445 }
446 #[cfg(feature = "strict")]
447 return _serde::__private::Err(
448 <__A::Error as _serde::de::Error>::duplicate_field(
449 "angularVelocity",
450 ),
451 );
452 }
453 m_angularVelocity = _serde::__private::Some(
454 match __A::next_value::<Vector4>(&mut __map) {
455 _serde::__private::Ok(__val) => __val,
456 _serde::__private::Err(__err) => {
457 return _serde::__private::Err(__err);
458 }
459 },
460 );
461 }
462 __Field::m_deactivationRefPosition => {
463 #[cfg(
464 any(feature = "strict", feature = "ignore_duplicates")
465 )]
466 if _serde::__private::Option::is_some(
467 &m_deactivationRefPosition,
468 ) {
469 #[cfg(feature = "ignore_duplicates")]
470 {
471 __A::skip_value(&mut __map)?;
472 continue;
473 }
474 #[cfg(feature = "strict")]
475 return _serde::__private::Err(
476 <__A::Error as _serde::de::Error>::duplicate_field(
477 "deactivationRefPosition",
478 ),
479 );
480 }
481 m_deactivationRefPosition = _serde::__private::Some(
482 match __A::next_value::<[Vector4; 2usize]>(&mut __map) {
483 _serde::__private::Ok(__val) => __val,
484 _serde::__private::Err(__err) => {
485 return _serde::__private::Err(__err);
486 }
487 },
488 );
489 }
490 __Field::m_deactivationRefOrientation => {
491 #[cfg(
492 any(feature = "strict", feature = "ignore_duplicates")
493 )]
494 if _serde::__private::Option::is_some(
495 &m_deactivationRefOrientation,
496 ) {
497 #[cfg(feature = "ignore_duplicates")]
498 {
499 __A::skip_value(&mut __map)?;
500 continue;
501 }
502 #[cfg(feature = "strict")]
503 return _serde::__private::Err(
504 <__A::Error as _serde::de::Error>::duplicate_field(
505 "deactivationRefOrientation",
506 ),
507 );
508 }
509 m_deactivationRefOrientation = _serde::__private::Some(
510 match __A::next_value::<[u32; 2usize]>(&mut __map) {
511 _serde::__private::Ok(__val) => __val,
512 _serde::__private::Err(__err) => {
513 return _serde::__private::Err(__err);
514 }
515 },
516 );
517 }
518 __Field::m_savedMotion => {
519 #[cfg(
520 any(feature = "strict", feature = "ignore_duplicates")
521 )]
522 if _serde::__private::Option::is_some(&m_savedMotion) {
523 #[cfg(feature = "ignore_duplicates")]
524 {
525 __A::skip_value(&mut __map)?;
526 continue;
527 }
528 #[cfg(feature = "strict")]
529 return _serde::__private::Err(
530 <__A::Error as _serde::de::Error>::duplicate_field(
531 "savedMotion",
532 ),
533 );
534 }
535 m_savedMotion = _serde::__private::Some(
536 match __A::next_value::<Pointer>(&mut __map) {
537 _serde::__private::Ok(__val) => __val,
538 _serde::__private::Err(__err) => {
539 return _serde::__private::Err(__err);
540 }
541 },
542 );
543 }
544 __Field::m_savedQualityTypeIndex => {
545 #[cfg(
546 any(feature = "strict", feature = "ignore_duplicates")
547 )]
548 if _serde::__private::Option::is_some(
549 &m_savedQualityTypeIndex,
550 ) {
551 #[cfg(feature = "ignore_duplicates")]
552 {
553 __A::skip_value(&mut __map)?;
554 continue;
555 }
556 #[cfg(feature = "strict")]
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::duplicate_field(
559 "savedQualityTypeIndex",
560 ),
561 );
562 }
563 m_savedQualityTypeIndex = _serde::__private::Some(
564 match __A::next_value::<u16>(&mut __map) {
565 _serde::__private::Ok(__val) => __val,
566 _serde::__private::Err(__err) => {
567 return _serde::__private::Err(__err);
568 }
569 },
570 );
571 }
572 __Field::m_gravityFactor => {
573 #[cfg(
574 any(feature = "strict", feature = "ignore_duplicates")
575 )]
576 if _serde::__private::Option::is_some(&m_gravityFactor) {
577 #[cfg(feature = "ignore_duplicates")]
578 {
579 __A::skip_value(&mut __map)?;
580 continue;
581 }
582 #[cfg(feature = "strict")]
583 return _serde::__private::Err(
584 <__A::Error as _serde::de::Error>::duplicate_field(
585 "gravityFactor",
586 ),
587 );
588 }
589 m_gravityFactor = _serde::__private::Some(
590 match __A::next_value::<f16>(&mut __map) {
591 _serde::__private::Ok(__val) => __val,
592 _serde::__private::Err(__err) => {
593 return _serde::__private::Err(__err);
594 }
595 },
596 );
597 }
598 _ => __A::skip_value(&mut __map)?,
599 }
600 }
601 let m_type = match m_type {
602 _serde::__private::Some(__field) => __field,
603 _serde::__private::None => {
604 #[cfg(feature = "strict")]
605 return _serde::__private::Err(
606 <__A::Error as _serde::de::Error>::missing_field("type"),
607 );
608 #[cfg(not(feature = "strict"))] Default::default()
609 }
610 };
611 let m_deactivationIntegrateCounter = match m_deactivationIntegrateCounter {
612 _serde::__private::Some(__field) => __field,
613 _serde::__private::None => {
614 #[cfg(feature = "strict")]
615 return _serde::__private::Err(
616 <__A::Error as _serde::de::Error>::missing_field(
617 "deactivationIntegrateCounter",
618 ),
619 );
620 #[cfg(not(feature = "strict"))] Default::default()
621 }
622 };
623 let m_deactivationNumInactiveFrames = match m_deactivationNumInactiveFrames {
624 _serde::__private::Some(__field) => __field,
625 _serde::__private::None => {
626 #[cfg(feature = "strict")]
627 return _serde::__private::Err(
628 <__A::Error as _serde::de::Error>::missing_field(
629 "deactivationNumInactiveFrames",
630 ),
631 );
632 #[cfg(not(feature = "strict"))] Default::default()
633 }
634 };
635 let m_motionState = match m_motionState {
636 _serde::__private::Some(__field) => __field,
637 _serde::__private::None => {
638 #[cfg(feature = "strict")]
639 return _serde::__private::Err(
640 <__A::Error as _serde::de::Error>::missing_field(
641 "motionState",
642 ),
643 );
644 #[cfg(not(feature = "strict"))] Default::default()
645 }
646 };
647 let m_inertiaAndMassInv = match m_inertiaAndMassInv {
648 _serde::__private::Some(__field) => __field,
649 _serde::__private::None => {
650 #[cfg(feature = "strict")]
651 return _serde::__private::Err(
652 <__A::Error as _serde::de::Error>::missing_field(
653 "inertiaAndMassInv",
654 ),
655 );
656 #[cfg(not(feature = "strict"))] Default::default()
657 }
658 };
659 let m_linearVelocity = match m_linearVelocity {
660 _serde::__private::Some(__field) => __field,
661 _serde::__private::None => {
662 #[cfg(feature = "strict")]
663 return _serde::__private::Err(
664 <__A::Error as _serde::de::Error>::missing_field(
665 "linearVelocity",
666 ),
667 );
668 #[cfg(not(feature = "strict"))] Default::default()
669 }
670 };
671 let m_angularVelocity = match m_angularVelocity {
672 _serde::__private::Some(__field) => __field,
673 _serde::__private::None => {
674 #[cfg(feature = "strict")]
675 return _serde::__private::Err(
676 <__A::Error as _serde::de::Error>::missing_field(
677 "angularVelocity",
678 ),
679 );
680 #[cfg(not(feature = "strict"))] Default::default()
681 }
682 };
683 let m_deactivationRefPosition = match m_deactivationRefPosition {
684 _serde::__private::Some(__field) => __field,
685 _serde::__private::None => {
686 #[cfg(feature = "strict")]
687 return _serde::__private::Err(
688 <__A::Error as _serde::de::Error>::missing_field(
689 "deactivationRefPosition",
690 ),
691 );
692 #[cfg(not(feature = "strict"))] Default::default()
693 }
694 };
695 let m_deactivationRefOrientation = match m_deactivationRefOrientation {
696 _serde::__private::Some(__field) => __field,
697 _serde::__private::None => {
698 #[cfg(feature = "strict")]
699 return _serde::__private::Err(
700 <__A::Error as _serde::de::Error>::missing_field(
701 "deactivationRefOrientation",
702 ),
703 );
704 #[cfg(not(feature = "strict"))] Default::default()
705 }
706 };
707 let m_savedMotion = match m_savedMotion {
708 _serde::__private::Some(__field) => __field,
709 _serde::__private::None => {
710 #[cfg(feature = "strict")]
711 return _serde::__private::Err(
712 <__A::Error as _serde::de::Error>::missing_field(
713 "savedMotion",
714 ),
715 );
716 #[cfg(not(feature = "strict"))] Default::default()
717 }
718 };
719 let m_savedQualityTypeIndex = match m_savedQualityTypeIndex {
720 _serde::__private::Some(__field) => __field,
721 _serde::__private::None => {
722 #[cfg(feature = "strict")]
723 return _serde::__private::Err(
724 <__A::Error as _serde::de::Error>::missing_field(
725 "savedQualityTypeIndex",
726 ),
727 );
728 #[cfg(not(feature = "strict"))] Default::default()
729 }
730 };
731 let m_gravityFactor = match m_gravityFactor {
732 _serde::__private::Some(__field) => __field,
733 _serde::__private::None => {
734 #[cfg(feature = "strict")]
735 return _serde::__private::Err(
736 <__A::Error as _serde::de::Error>::missing_field(
737 "gravityFactor",
738 ),
739 );
740 #[cfg(not(feature = "strict"))] Default::default()
741 }
742 };
743 let __ptr = None;
744 let parent = hkBaseObject { __ptr };
745 let parent = hkReferencedObject {
746 __ptr,
747 parent,
748 ..Default::default()
749 };
750 let parent = hkpMotion {
751 __ptr,
752 parent,
753 m_type,
754 m_deactivationIntegrateCounter,
755 m_deactivationNumInactiveFrames,
756 m_motionState,
757 m_inertiaAndMassInv,
758 m_linearVelocity,
759 m_angularVelocity,
760 m_deactivationRefPosition,
761 m_deactivationRefOrientation,
762 m_savedMotion,
763 m_savedQualityTypeIndex,
764 m_gravityFactor,
765 };
766 let parent = hkpBoxMotion { __ptr, parent };
767 let __ptr = __A::class_ptr(&mut __map);
768 _serde::__private::Ok(hkpThinBoxMotion { __ptr, parent })
769 }
770 }
771 const FIELDS: &[&str] = &[];
772 _serde::Deserializer::deserialize_struct(
773 deserializer,
774 "hkpThinBoxMotion",
775 FIELDS,
776 __hkpThinBoxMotionVisitor {
777 marker: _serde::__private::PhantomData::<hkpThinBoxMotion>,
778 lifetime: _serde::__private::PhantomData,
779 },
780 )
781 }
782 }
783};