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 hkpRigidBody<'a> {
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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkpEntity<'a>,
31}
32const _: () = {
33 use havok_serde as _serde;
34 impl<'a> _serde::HavokClass for hkpRigidBody<'a> {
35 #[inline]
36 fn name(&self) -> &'static str {
37 "hkpRigidBody"
38 }
39 #[inline]
40 fn signature(&self) -> _serde::__private::Signature {
41 _serde::__private::Signature::new(0x75f8d805)
42 }
43 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
44 fn deps_indexes(&self) -> Vec<usize> {
45 let mut v = Vec::new();
46 v.push(self.parent.parent.m_world.get());
47 v.extend(self.parent.parent.m_collidable.deps_indexes());
48 v.extend(self.parent.parent.m_multiThreadCheck.deps_indexes());
49 v.extend(
50 self
51 .parent
52 .parent
53 .m_properties
54 .iter()
55 .flat_map(|class| class.deps_indexes())
56 .collect::<Vec<usize>>(),
57 );
58 v.push(self.parent.parent.m_treeData.get());
59 v.extend(self.parent.m_material.deps_indexes());
60 v.push(self.parent.m_limitContactImpulseUtilAndFlag.get());
61 v.push(self.parent.m_breakableBody.get());
62 v.extend(self.parent.m_constraintsMaster.deps_indexes());
63 v.extend(self.parent.m_constraintsSlave.iter().map(|ptr| ptr.get()));
64 v.push(self.parent.m_simulationIsland.get());
65 v.extend(self.parent.m_spuCollisionCallback.deps_indexes());
66 v.extend(self.parent.m_motion.deps_indexes());
67 v.extend(self.parent.m_contactListeners.deps_indexes());
68 v.extend(self.parent.m_actions.deps_indexes());
69 v.push(self.parent.m_localFrame.get());
70 v.push(self.parent.m_extendedListeners.get());
71 v
72 }
73 }
74 impl<'a> _serde::Serialize for hkpRigidBody<'a> {
75 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
76 where
77 S: _serde::ser::Serializer,
78 {
79 let class_meta = self
80 .__ptr
81 .map(|name| (name, _serde::__private::Signature::new(0x75f8d805)));
82 let mut serializer = __serializer
83 .serialize_struct("hkpRigidBody", class_meta, (544u64, 720u64))?;
84 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
85 serializer
86 .skip_field(
87 "memSizeAndFlags",
88 &self.parent.parent.parent.m_memSizeAndFlags,
89 )?;
90 serializer
91 .skip_field(
92 "referenceCount",
93 &self.parent.parent.parent.m_referenceCount,
94 )?;
95 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
96 serializer.skip_field("world", &self.parent.parent.m_world)?;
97 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
98 serializer.serialize_field("collidable", &self.parent.parent.m_collidable)?;
99 serializer
100 .serialize_field(
101 "multiThreadCheck",
102 &self.parent.parent.m_multiThreadCheck,
103 )?;
104 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
105 serializer.serialize_field("name", &self.parent.parent.m_name)?;
106 serializer
107 .serialize_array_field(
108 "properties",
109 &self.parent.parent.m_properties,
110 TypeSize::Struct {
111 size_x86: 16u64,
112 size_x86_64: 16u64,
113 },
114 )?;
115 serializer.skip_field("treeData", &self.parent.parent.m_treeData)?;
116 serializer.serialize_field("material", &self.parent.m_material)?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer
119 .skip_field(
120 "limitContactImpulseUtilAndFlag",
121 &self.parent.m_limitContactImpulseUtilAndFlag,
122 )?;
123 serializer
124 .serialize_field("damageMultiplier", &self.parent.m_damageMultiplier)?;
125 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
126 serializer.skip_field("breakableBody", &self.parent.m_breakableBody)?;
127 serializer.skip_field("solverData", &self.parent.m_solverData)?;
128 serializer.serialize_field("storageIndex", &self.parent.m_storageIndex)?;
129 serializer
130 .serialize_field(
131 "contactPointCallbackDelay",
132 &self.parent.m_contactPointCallbackDelay,
133 )?;
134 serializer
135 .skip_field("constraintsMaster", &self.parent.m_constraintsMaster)?;
136 serializer
137 .skip_array_field(
138 "constraintsSlave",
139 &self.parent.m_constraintsSlave,
140 TypeSize::NonPtr,
141 )?;
142 serializer
143 .skip_array_field(
144 "constraintRuntime",
145 &self.parent.m_constraintRuntime,
146 TypeSize::NonPtr,
147 )?;
148 serializer.skip_field("simulationIsland", &self.parent.m_simulationIsland)?;
149 serializer
150 .serialize_field("autoRemoveLevel", &self.parent.m_autoRemoveLevel)?;
151 serializer
152 .serialize_field(
153 "numShapeKeysInContactPointProperties",
154 &self.parent.m_numShapeKeysInContactPointProperties,
155 )?;
156 serializer
157 .serialize_field(
158 "responseModifierFlags",
159 &self.parent.m_responseModifierFlags,
160 )?;
161 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
162 serializer.serialize_field("uid", &self.parent.m_uid)?;
163 serializer
164 .serialize_field(
165 "spuCollisionCallback",
166 &self.parent.m_spuCollisionCallback,
167 )?;
168 serializer.serialize_field("motion", &self.parent.m_motion)?;
169 serializer.skip_field("contactListeners", &self.parent.m_contactListeners)?;
170 serializer.skip_field("actions", &self.parent.m_actions)?;
171 serializer.serialize_field("localFrame", &self.parent.m_localFrame)?;
172 serializer
173 .skip_field("extendedListeners", &self.parent.m_extendedListeners)?;
174 serializer.serialize_field("npData", &self.parent.m_npData)?;
175 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 12usize].as_slice())?;
176 serializer.end()
177 }
178 }
179};
180#[doc(hidden)]
181#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
182const _: () = {
183 use havok_serde as _serde;
184 #[automatically_derived]
185 impl<'de> _serde::Deserialize<'de> for hkpRigidBody<'de> {
186 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
187 where
188 __D: _serde::Deserializer<'de>,
189 {
190 #[allow(non_camel_case_types)]
191 enum __Field {
192 m_userData,
193 m_collidable,
194 m_multiThreadCheck,
195 m_name,
196 m_properties,
197 m_material,
198 m_damageMultiplier,
199 m_storageIndex,
200 m_contactPointCallbackDelay,
201 m_autoRemoveLevel,
202 m_numShapeKeysInContactPointProperties,
203 m_responseModifierFlags,
204 m_uid,
205 m_spuCollisionCallback,
206 m_motion,
207 m_localFrame,
208 m_npData,
209 __ignore,
210 }
211 struct __FieldVisitor;
212 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
213 type Value = __Field;
214 fn expecting(
215 &self,
216 __formatter: &mut core::fmt::Formatter,
217 ) -> core::fmt::Result {
218 core::fmt::Formatter::write_str(__formatter, "field identifier")
219 }
220 #[allow(clippy::match_single_binding)]
222 #[allow(clippy::reversed_empty_ranges)]
223 #[allow(clippy::single_match)]
224 fn visit_key<__E>(
225 self,
226 __value: &str,
227 ) -> core::result::Result<Self::Value, __E>
228 where
229 __E: _serde::de::Error,
230 {
231 match __value {
232 "userData" => Ok(__Field::m_userData),
233 "collidable" => Ok(__Field::m_collidable),
234 "multiThreadCheck" => Ok(__Field::m_multiThreadCheck),
235 "name" => Ok(__Field::m_name),
236 "properties" => Ok(__Field::m_properties),
237 "material" => Ok(__Field::m_material),
238 "damageMultiplier" => Ok(__Field::m_damageMultiplier),
239 "storageIndex" => Ok(__Field::m_storageIndex),
240 "contactPointCallbackDelay" => {
241 Ok(__Field::m_contactPointCallbackDelay)
242 }
243 "autoRemoveLevel" => Ok(__Field::m_autoRemoveLevel),
244 "numShapeKeysInContactPointProperties" => {
245 Ok(__Field::m_numShapeKeysInContactPointProperties)
246 }
247 "responseModifierFlags" => Ok(__Field::m_responseModifierFlags),
248 "uid" => Ok(__Field::m_uid),
249 "spuCollisionCallback" => Ok(__Field::m_spuCollisionCallback),
250 "motion" => Ok(__Field::m_motion),
251 "localFrame" => Ok(__Field::m_localFrame),
252 "npData" => Ok(__Field::m_npData),
253 _ => Ok(__Field::__ignore),
254 }
255 }
256 }
257 impl<'de> _serde::Deserialize<'de> for __Field {
258 #[inline]
259 fn deserialize<__D>(
260 __deserializer: __D,
261 ) -> core::result::Result<Self, __D::Error>
262 where
263 __D: _serde::Deserializer<'de>,
264 {
265 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
266 }
267 }
268 struct __hkpRigidBodyVisitor<'de> {
269 marker: _serde::__private::PhantomData<hkpRigidBody<'de>>,
270 lifetime: _serde::__private::PhantomData<&'de ()>,
271 }
272 #[allow(clippy::match_single_binding)]
273 #[allow(clippy::reversed_empty_ranges)]
274 #[allow(clippy::single_match)]
275 impl<'de> _serde::de::Visitor<'de> for __hkpRigidBodyVisitor<'de> {
276 type Value = hkpRigidBody<'de>;
277 fn expecting(
278 &self,
279 __formatter: &mut core::fmt::Formatter,
280 ) -> core::fmt::Result {
281 core::fmt::Formatter::write_str(__formatter, "struct hkpRigidBody")
282 }
283 fn visit_struct_for_bytes<__A>(
284 self,
285 mut __map: __A,
286 ) -> _serde::__private::Result<Self::Value, __A::Error>
287 where
288 __A: _serde::de::MapAccess<'de>,
289 {
290 let __ptr = __A::class_ptr(&mut __map);
291 let parent = __A::parent_value(&mut __map)?;
292 for i in 0..0usize {
293 match i {
294 _ => {}
295 }
296 }
297 _serde::__private::Ok(hkpRigidBody { __ptr, parent })
298 }
299 #[allow(clippy::manual_unwrap_or_default)]
300 fn visit_struct<__A>(
301 self,
302 mut __map: __A,
303 ) -> _serde::__private::Result<Self::Value, __A::Error>
304 where
305 __A: _serde::de::MapAccess<'de>,
306 {
307 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
308 let mut m_collidable: _serde::__private::Option<
309 hkpLinkedCollidable,
310 > = _serde::__private::None;
311 let mut m_multiThreadCheck: _serde::__private::Option<
312 hkMultiThreadCheck,
313 > = _serde::__private::None;
314 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
315 let mut m_properties: _serde::__private::Option<Vec<hkpProperty>> = _serde::__private::None;
316 let mut m_material: _serde::__private::Option<hkpMaterial> = _serde::__private::None;
317 let mut m_damageMultiplier: _serde::__private::Option<f32> = _serde::__private::None;
318 let mut m_storageIndex: _serde::__private::Option<u16> = _serde::__private::None;
319 let mut m_contactPointCallbackDelay: _serde::__private::Option<
320 u16,
321 > = _serde::__private::None;
322 let mut m_autoRemoveLevel: _serde::__private::Option<i8> = _serde::__private::None;
323 let mut m_numShapeKeysInContactPointProperties: _serde::__private::Option<
324 u8,
325 > = _serde::__private::None;
326 let mut m_responseModifierFlags: _serde::__private::Option<u8> = _serde::__private::None;
327 let mut m_uid: _serde::__private::Option<u32> = _serde::__private::None;
328 let mut m_spuCollisionCallback: _serde::__private::Option<
329 hkpEntitySpuCollisionCallback,
330 > = _serde::__private::None;
331 let mut m_motion: _serde::__private::Option<hkpMaxSizeMotion> = _serde::__private::None;
332 let mut m_localFrame: _serde::__private::Option<Pointer> = _serde::__private::None;
333 let mut m_npData: _serde::__private::Option<u32> = _serde::__private::None;
334 while let _serde::__private::Some(__key) = {
335 __A::next_key::<__Field>(&mut __map)?
336 } {
337 match __key {
338 __Field::m_userData => {
339 #[cfg(
340 any(feature = "strict", feature = "ignore_duplicates")
341 )]
342 if _serde::__private::Option::is_some(&m_userData) {
343 #[cfg(feature = "ignore_duplicates")]
344 {
345 __A::skip_value(&mut __map)?;
346 continue;
347 }
348 #[cfg(feature = "strict")]
349 return _serde::__private::Err(
350 <__A::Error as _serde::de::Error>::duplicate_field(
351 "userData",
352 ),
353 );
354 }
355 m_userData = _serde::__private::Some(
356 match __A::next_value::<Ulong>(&mut __map) {
357 _serde::__private::Ok(__val) => __val,
358 _serde::__private::Err(__err) => {
359 return _serde::__private::Err(__err);
360 }
361 },
362 );
363 }
364 __Field::m_collidable => {
365 #[cfg(
366 any(feature = "strict", feature = "ignore_duplicates")
367 )]
368 if _serde::__private::Option::is_some(&m_collidable) {
369 #[cfg(feature = "ignore_duplicates")]
370 {
371 __A::skip_value(&mut __map)?;
372 continue;
373 }
374 #[cfg(feature = "strict")]
375 return _serde::__private::Err(
376 <__A::Error as _serde::de::Error>::duplicate_field(
377 "collidable",
378 ),
379 );
380 }
381 m_collidable = _serde::__private::Some(
382 match __A::next_value::<hkpLinkedCollidable>(&mut __map) {
383 _serde::__private::Ok(__val) => __val,
384 _serde::__private::Err(__err) => {
385 return _serde::__private::Err(__err);
386 }
387 },
388 );
389 }
390 __Field::m_multiThreadCheck => {
391 #[cfg(
392 any(feature = "strict", feature = "ignore_duplicates")
393 )]
394 if _serde::__private::Option::is_some(&m_multiThreadCheck) {
395 #[cfg(feature = "ignore_duplicates")]
396 {
397 __A::skip_value(&mut __map)?;
398 continue;
399 }
400 #[cfg(feature = "strict")]
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "multiThreadCheck",
404 ),
405 );
406 }
407 m_multiThreadCheck = _serde::__private::Some(
408 match __A::next_value::<hkMultiThreadCheck>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 __Field::m_name => {
417 #[cfg(
418 any(feature = "strict", feature = "ignore_duplicates")
419 )]
420 if _serde::__private::Option::is_some(&m_name) {
421 #[cfg(feature = "ignore_duplicates")]
422 {
423 __A::skip_value(&mut __map)?;
424 continue;
425 }
426 #[cfg(feature = "strict")]
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field("name"),
429 );
430 }
431 m_name = _serde::__private::Some(
432 match __A::next_value::<StringPtr<'de>>(&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_properties => {
441 #[cfg(
442 any(feature = "strict", feature = "ignore_duplicates")
443 )]
444 if _serde::__private::Option::is_some(&m_properties) {
445 #[cfg(feature = "ignore_duplicates")]
446 {
447 __A::skip_value(&mut __map)?;
448 continue;
449 }
450 #[cfg(feature = "strict")]
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::duplicate_field(
453 "properties",
454 ),
455 );
456 }
457 m_properties = _serde::__private::Some(
458 match __A::next_value::<Vec<hkpProperty>>(&mut __map) {
459 _serde::__private::Ok(__val) => __val,
460 _serde::__private::Err(__err) => {
461 return _serde::__private::Err(__err);
462 }
463 },
464 );
465 }
466 __Field::m_material => {
467 #[cfg(
468 any(feature = "strict", feature = "ignore_duplicates")
469 )]
470 if _serde::__private::Option::is_some(&m_material) {
471 #[cfg(feature = "ignore_duplicates")]
472 {
473 __A::skip_value(&mut __map)?;
474 continue;
475 }
476 #[cfg(feature = "strict")]
477 return _serde::__private::Err(
478 <__A::Error as _serde::de::Error>::duplicate_field(
479 "material",
480 ),
481 );
482 }
483 m_material = _serde::__private::Some(
484 match __A::next_value::<hkpMaterial>(&mut __map) {
485 _serde::__private::Ok(__val) => __val,
486 _serde::__private::Err(__err) => {
487 return _serde::__private::Err(__err);
488 }
489 },
490 );
491 }
492 __Field::m_damageMultiplier => {
493 #[cfg(
494 any(feature = "strict", feature = "ignore_duplicates")
495 )]
496 if _serde::__private::Option::is_some(&m_damageMultiplier) {
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 "damageMultiplier",
506 ),
507 );
508 }
509 m_damageMultiplier = _serde::__private::Some(
510 match __A::next_value::<f32>(&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_storageIndex => {
519 #[cfg(
520 any(feature = "strict", feature = "ignore_duplicates")
521 )]
522 if _serde::__private::Option::is_some(&m_storageIndex) {
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 "storageIndex",
532 ),
533 );
534 }
535 m_storageIndex = _serde::__private::Some(
536 match __A::next_value::<u16>(&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_contactPointCallbackDelay => {
545 #[cfg(
546 any(feature = "strict", feature = "ignore_duplicates")
547 )]
548 if _serde::__private::Option::is_some(
549 &m_contactPointCallbackDelay,
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 "contactPointCallbackDelay",
560 ),
561 );
562 }
563 m_contactPointCallbackDelay = _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_autoRemoveLevel => {
573 #[cfg(
574 any(feature = "strict", feature = "ignore_duplicates")
575 )]
576 if _serde::__private::Option::is_some(&m_autoRemoveLevel) {
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 "autoRemoveLevel",
586 ),
587 );
588 }
589 m_autoRemoveLevel = _serde::__private::Some(
590 match __A::next_value::<i8>(&mut __map) {
591 _serde::__private::Ok(__val) => __val,
592 _serde::__private::Err(__err) => {
593 return _serde::__private::Err(__err);
594 }
595 },
596 );
597 }
598 __Field::m_numShapeKeysInContactPointProperties => {
599 #[cfg(
600 any(feature = "strict", feature = "ignore_duplicates")
601 )]
602 if _serde::__private::Option::is_some(
603 &m_numShapeKeysInContactPointProperties,
604 ) {
605 #[cfg(feature = "ignore_duplicates")]
606 {
607 __A::skip_value(&mut __map)?;
608 continue;
609 }
610 #[cfg(feature = "strict")]
611 return _serde::__private::Err(
612 <__A::Error as _serde::de::Error>::duplicate_field(
613 "numShapeKeysInContactPointProperties",
614 ),
615 );
616 }
617 m_numShapeKeysInContactPointProperties = _serde::__private::Some(
618 match __A::next_value::<u8>(&mut __map) {
619 _serde::__private::Ok(__val) => __val,
620 _serde::__private::Err(__err) => {
621 return _serde::__private::Err(__err);
622 }
623 },
624 );
625 }
626 __Field::m_responseModifierFlags => {
627 #[cfg(
628 any(feature = "strict", feature = "ignore_duplicates")
629 )]
630 if _serde::__private::Option::is_some(
631 &m_responseModifierFlags,
632 ) {
633 #[cfg(feature = "ignore_duplicates")]
634 {
635 __A::skip_value(&mut __map)?;
636 continue;
637 }
638 #[cfg(feature = "strict")]
639 return _serde::__private::Err(
640 <__A::Error as _serde::de::Error>::duplicate_field(
641 "responseModifierFlags",
642 ),
643 );
644 }
645 m_responseModifierFlags = _serde::__private::Some(
646 match __A::next_value::<u8>(&mut __map) {
647 _serde::__private::Ok(__val) => __val,
648 _serde::__private::Err(__err) => {
649 return _serde::__private::Err(__err);
650 }
651 },
652 );
653 }
654 __Field::m_uid => {
655 #[cfg(
656 any(feature = "strict", feature = "ignore_duplicates")
657 )]
658 if _serde::__private::Option::is_some(&m_uid) {
659 #[cfg(feature = "ignore_duplicates")]
660 {
661 __A::skip_value(&mut __map)?;
662 continue;
663 }
664 #[cfg(feature = "strict")]
665 return _serde::__private::Err(
666 <__A::Error as _serde::de::Error>::duplicate_field("uid"),
667 );
668 }
669 m_uid = _serde::__private::Some(
670 match __A::next_value::<u32>(&mut __map) {
671 _serde::__private::Ok(__val) => __val,
672 _serde::__private::Err(__err) => {
673 return _serde::__private::Err(__err);
674 }
675 },
676 );
677 }
678 __Field::m_spuCollisionCallback => {
679 #[cfg(
680 any(feature = "strict", feature = "ignore_duplicates")
681 )]
682 if _serde::__private::Option::is_some(
683 &m_spuCollisionCallback,
684 ) {
685 #[cfg(feature = "ignore_duplicates")]
686 {
687 __A::skip_value(&mut __map)?;
688 continue;
689 }
690 #[cfg(feature = "strict")]
691 return _serde::__private::Err(
692 <__A::Error as _serde::de::Error>::duplicate_field(
693 "spuCollisionCallback",
694 ),
695 );
696 }
697 m_spuCollisionCallback = _serde::__private::Some(
698 match __A::next_value::<
699 hkpEntitySpuCollisionCallback,
700 >(&mut __map) {
701 _serde::__private::Ok(__val) => __val,
702 _serde::__private::Err(__err) => {
703 return _serde::__private::Err(__err);
704 }
705 },
706 );
707 }
708 __Field::m_motion => {
709 #[cfg(
710 any(feature = "strict", feature = "ignore_duplicates")
711 )]
712 if _serde::__private::Option::is_some(&m_motion) {
713 #[cfg(feature = "ignore_duplicates")]
714 {
715 __A::skip_value(&mut __map)?;
716 continue;
717 }
718 #[cfg(feature = "strict")]
719 return _serde::__private::Err(
720 <__A::Error as _serde::de::Error>::duplicate_field("motion"),
721 );
722 }
723 m_motion = _serde::__private::Some(
724 match __A::next_value::<hkpMaxSizeMotion>(&mut __map) {
725 _serde::__private::Ok(__val) => __val,
726 _serde::__private::Err(__err) => {
727 return _serde::__private::Err(__err);
728 }
729 },
730 );
731 }
732 __Field::m_localFrame => {
733 #[cfg(
734 any(feature = "strict", feature = "ignore_duplicates")
735 )]
736 if _serde::__private::Option::is_some(&m_localFrame) {
737 #[cfg(feature = "ignore_duplicates")]
738 {
739 __A::skip_value(&mut __map)?;
740 continue;
741 }
742 #[cfg(feature = "strict")]
743 return _serde::__private::Err(
744 <__A::Error as _serde::de::Error>::duplicate_field(
745 "localFrame",
746 ),
747 );
748 }
749 m_localFrame = _serde::__private::Some(
750 match __A::next_value::<Pointer>(&mut __map) {
751 _serde::__private::Ok(__val) => __val,
752 _serde::__private::Err(__err) => {
753 return _serde::__private::Err(__err);
754 }
755 },
756 );
757 }
758 __Field::m_npData => {
759 #[cfg(
760 any(feature = "strict", feature = "ignore_duplicates")
761 )]
762 if _serde::__private::Option::is_some(&m_npData) {
763 #[cfg(feature = "ignore_duplicates")]
764 {
765 __A::skip_value(&mut __map)?;
766 continue;
767 }
768 #[cfg(feature = "strict")]
769 return _serde::__private::Err(
770 <__A::Error as _serde::de::Error>::duplicate_field("npData"),
771 );
772 }
773 m_npData = _serde::__private::Some(
774 match __A::next_value::<u32>(&mut __map) {
775 _serde::__private::Ok(__val) => __val,
776 _serde::__private::Err(__err) => {
777 return _serde::__private::Err(__err);
778 }
779 },
780 );
781 }
782 _ => __A::skip_value(&mut __map)?,
783 }
784 }
785 let m_userData = match m_userData {
786 _serde::__private::Some(__field) => __field,
787 _serde::__private::None => {
788 #[cfg(feature = "strict")]
789 return _serde::__private::Err(
790 <__A::Error as _serde::de::Error>::missing_field("userData"),
791 );
792 #[cfg(not(feature = "strict"))] Default::default()
793 }
794 };
795 let m_collidable = match m_collidable {
796 _serde::__private::Some(__field) => __field,
797 _serde::__private::None => {
798 #[cfg(feature = "strict")]
799 return _serde::__private::Err(
800 <__A::Error as _serde::de::Error>::missing_field(
801 "collidable",
802 ),
803 );
804 #[cfg(not(feature = "strict"))] Default::default()
805 }
806 };
807 let m_multiThreadCheck = match m_multiThreadCheck {
808 _serde::__private::Some(__field) => __field,
809 _serde::__private::None => {
810 #[cfg(feature = "strict")]
811 return _serde::__private::Err(
812 <__A::Error as _serde::de::Error>::missing_field(
813 "multiThreadCheck",
814 ),
815 );
816 #[cfg(not(feature = "strict"))] Default::default()
817 }
818 };
819 let m_name = match m_name {
820 _serde::__private::Some(__field) => __field,
821 _serde::__private::None => {
822 #[cfg(feature = "strict")]
823 return _serde::__private::Err(
824 <__A::Error as _serde::de::Error>::missing_field("name"),
825 );
826 #[cfg(not(feature = "strict"))] Default::default()
827 }
828 };
829 let m_properties = match m_properties {
830 _serde::__private::Some(__field) => __field,
831 _serde::__private::None => {
832 #[cfg(feature = "strict")]
833 return _serde::__private::Err(
834 <__A::Error as _serde::de::Error>::missing_field(
835 "properties",
836 ),
837 );
838 #[cfg(not(feature = "strict"))] Default::default()
839 }
840 };
841 let m_material = match m_material {
842 _serde::__private::Some(__field) => __field,
843 _serde::__private::None => {
844 #[cfg(feature = "strict")]
845 return _serde::__private::Err(
846 <__A::Error as _serde::de::Error>::missing_field("material"),
847 );
848 #[cfg(not(feature = "strict"))] Default::default()
849 }
850 };
851 let m_damageMultiplier = match m_damageMultiplier {
852 _serde::__private::Some(__field) => __field,
853 _serde::__private::None => {
854 #[cfg(feature = "strict")]
855 return _serde::__private::Err(
856 <__A::Error as _serde::de::Error>::missing_field(
857 "damageMultiplier",
858 ),
859 );
860 #[cfg(not(feature = "strict"))] Default::default()
861 }
862 };
863 let m_storageIndex = match m_storageIndex {
864 _serde::__private::Some(__field) => __field,
865 _serde::__private::None => {
866 #[cfg(feature = "strict")]
867 return _serde::__private::Err(
868 <__A::Error as _serde::de::Error>::missing_field(
869 "storageIndex",
870 ),
871 );
872 #[cfg(not(feature = "strict"))] Default::default()
873 }
874 };
875 let m_contactPointCallbackDelay = match m_contactPointCallbackDelay {
876 _serde::__private::Some(__field) => __field,
877 _serde::__private::None => {
878 #[cfg(feature = "strict")]
879 return _serde::__private::Err(
880 <__A::Error as _serde::de::Error>::missing_field(
881 "contactPointCallbackDelay",
882 ),
883 );
884 #[cfg(not(feature = "strict"))] Default::default()
885 }
886 };
887 let m_autoRemoveLevel = match m_autoRemoveLevel {
888 _serde::__private::Some(__field) => __field,
889 _serde::__private::None => {
890 #[cfg(feature = "strict")]
891 return _serde::__private::Err(
892 <__A::Error as _serde::de::Error>::missing_field(
893 "autoRemoveLevel",
894 ),
895 );
896 #[cfg(not(feature = "strict"))] Default::default()
897 }
898 };
899 let m_numShapeKeysInContactPointProperties = match m_numShapeKeysInContactPointProperties {
900 _serde::__private::Some(__field) => __field,
901 _serde::__private::None => {
902 #[cfg(feature = "strict")]
903 return _serde::__private::Err(
904 <__A::Error as _serde::de::Error>::missing_field(
905 "numShapeKeysInContactPointProperties",
906 ),
907 );
908 #[cfg(not(feature = "strict"))] Default::default()
909 }
910 };
911 let m_responseModifierFlags = match m_responseModifierFlags {
912 _serde::__private::Some(__field) => __field,
913 _serde::__private::None => {
914 #[cfg(feature = "strict")]
915 return _serde::__private::Err(
916 <__A::Error as _serde::de::Error>::missing_field(
917 "responseModifierFlags",
918 ),
919 );
920 #[cfg(not(feature = "strict"))] Default::default()
921 }
922 };
923 let m_uid = match m_uid {
924 _serde::__private::Some(__field) => __field,
925 _serde::__private::None => {
926 #[cfg(feature = "strict")]
927 return _serde::__private::Err(
928 <__A::Error as _serde::de::Error>::missing_field("uid"),
929 );
930 #[cfg(not(feature = "strict"))] Default::default()
931 }
932 };
933 let m_spuCollisionCallback = match m_spuCollisionCallback {
934 _serde::__private::Some(__field) => __field,
935 _serde::__private::None => {
936 #[cfg(feature = "strict")]
937 return _serde::__private::Err(
938 <__A::Error as _serde::de::Error>::missing_field(
939 "spuCollisionCallback",
940 ),
941 );
942 #[cfg(not(feature = "strict"))] Default::default()
943 }
944 };
945 let m_motion = match m_motion {
946 _serde::__private::Some(__field) => __field,
947 _serde::__private::None => {
948 #[cfg(feature = "strict")]
949 return _serde::__private::Err(
950 <__A::Error as _serde::de::Error>::missing_field("motion"),
951 );
952 #[cfg(not(feature = "strict"))] Default::default()
953 }
954 };
955 let m_localFrame = match m_localFrame {
956 _serde::__private::Some(__field) => __field,
957 _serde::__private::None => {
958 #[cfg(feature = "strict")]
959 return _serde::__private::Err(
960 <__A::Error as _serde::de::Error>::missing_field(
961 "localFrame",
962 ),
963 );
964 #[cfg(not(feature = "strict"))] Default::default()
965 }
966 };
967 let m_npData = match m_npData {
968 _serde::__private::Some(__field) => __field,
969 _serde::__private::None => {
970 #[cfg(feature = "strict")]
971 return _serde::__private::Err(
972 <__A::Error as _serde::de::Error>::missing_field("npData"),
973 );
974 #[cfg(not(feature = "strict"))] Default::default()
975 }
976 };
977 let __ptr = None;
978 let parent = hkBaseObject { __ptr };
979 let parent = hkReferencedObject {
980 __ptr,
981 parent,
982 ..Default::default()
983 };
984 let parent = hkpWorldObject {
985 __ptr,
986 parent,
987 m_userData,
988 m_collidable,
989 m_multiThreadCheck,
990 m_name,
991 m_properties,
992 ..Default::default()
993 };
994 let parent = hkpEntity {
995 __ptr,
996 parent,
997 m_material,
998 m_damageMultiplier,
999 m_storageIndex,
1000 m_contactPointCallbackDelay,
1001 m_autoRemoveLevel,
1002 m_numShapeKeysInContactPointProperties,
1003 m_responseModifierFlags,
1004 m_uid,
1005 m_spuCollisionCallback,
1006 m_motion,
1007 m_localFrame,
1008 m_npData,
1009 ..Default::default()
1010 };
1011 let __ptr = __A::class_ptr(&mut __map);
1012 _serde::__private::Ok(hkpRigidBody { __ptr, parent })
1013 }
1014 }
1015 const FIELDS: &[&str] = &[];
1016 _serde::Deserializer::deserialize_struct(
1017 deserializer,
1018 "hkpRigidBody",
1019 FIELDS,
1020 __hkpRigidBodyVisitor {
1021 marker: _serde::__private::PhantomData::<hkpRigidBody>,
1022 lifetime: _serde::__private::PhantomData,
1023 },
1024 )
1025 }
1026 }
1027};