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