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