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