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 hkpEntity<'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: hkpWorldObject<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "material"))]
36 #[cfg_attr(feature = "serde", serde(rename = "material"))]
37 pub m_material: hkpMaterial,
38 #[cfg_attr(
44 feature = "json_schema",
45 schemars(rename = "limitContactImpulseUtilAndFlag")
46 )]
47 #[cfg_attr(feature = "serde", serde(rename = "limitContactImpulseUtilAndFlag"))]
48 pub m_limitContactImpulseUtilAndFlag: Pointer,
49 #[cfg_attr(feature = "json_schema", schemars(rename = "damageMultiplier"))]
54 #[cfg_attr(feature = "serde", serde(rename = "damageMultiplier"))]
55 pub m_damageMultiplier: f32,
56 #[cfg_attr(feature = "json_schema", schemars(rename = "breakableBody"))]
62 #[cfg_attr(feature = "serde", serde(rename = "breakableBody"))]
63 pub m_breakableBody: Pointer,
64 #[cfg_attr(feature = "json_schema", schemars(rename = "solverData"))]
70 #[cfg_attr(feature = "serde", serde(rename = "solverData"))]
71 pub m_solverData: u32,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "storageIndex"))]
77 #[cfg_attr(feature = "serde", serde(rename = "storageIndex"))]
78 pub m_storageIndex: u16,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "contactPointCallbackDelay"))]
84 #[cfg_attr(feature = "serde", serde(rename = "contactPointCallbackDelay"))]
85 pub m_contactPointCallbackDelay: u16,
86 #[cfg_attr(feature = "json_schema", schemars(rename = "constraintsMaster"))]
92 #[cfg_attr(feature = "serde", serde(rename = "constraintsMaster"))]
93 pub m_constraintsMaster: hkpEntitySmallArraySerializeOverrideType,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "constraintsSlave"))]
100 #[cfg_attr(feature = "serde", serde(rename = "constraintsSlave"))]
101 pub m_constraintsSlave: Vec<Pointer>,
102 #[cfg_attr(feature = "json_schema", schemars(rename = "constraintRuntime"))]
108 #[cfg_attr(feature = "serde", serde(rename = "constraintRuntime"))]
109 pub m_constraintRuntime: Vec<u8>,
110 #[cfg_attr(feature = "json_schema", schemars(rename = "simulationIsland"))]
116 #[cfg_attr(feature = "serde", serde(rename = "simulationIsland"))]
117 pub m_simulationIsland: Pointer,
118 #[cfg_attr(feature = "json_schema", schemars(rename = "autoRemoveLevel"))]
123 #[cfg_attr(feature = "serde", serde(rename = "autoRemoveLevel"))]
124 pub m_autoRemoveLevel: i8,
125 #[cfg_attr(
130 feature = "json_schema",
131 schemars(rename = "numShapeKeysInContactPointProperties")
132 )]
133 #[cfg_attr(
134 feature = "serde",
135 serde(rename = "numShapeKeysInContactPointProperties")
136 )]
137 pub m_numShapeKeysInContactPointProperties: u8,
138 #[cfg_attr(feature = "json_schema", schemars(rename = "responseModifierFlags"))]
143 #[cfg_attr(feature = "serde", serde(rename = "responseModifierFlags"))]
144 pub m_responseModifierFlags: u8,
145 #[cfg_attr(feature = "json_schema", schemars(rename = "uid"))]
150 #[cfg_attr(feature = "serde", serde(rename = "uid"))]
151 pub m_uid: u32,
152 #[cfg_attr(feature = "json_schema", schemars(rename = "spuCollisionCallback"))]
157 #[cfg_attr(feature = "serde", serde(rename = "spuCollisionCallback"))]
158 pub m_spuCollisionCallback: hkpEntitySpuCollisionCallback,
159 #[cfg_attr(feature = "json_schema", schemars(rename = "motion"))]
164 #[cfg_attr(feature = "serde", serde(rename = "motion"))]
165 pub m_motion: hkpMaxSizeMotion,
166 #[cfg_attr(feature = "json_schema", schemars(rename = "contactListeners"))]
172 #[cfg_attr(feature = "serde", serde(rename = "contactListeners"))]
173 pub m_contactListeners: hkpEntitySmallArraySerializeOverrideType,
174 #[cfg_attr(feature = "json_schema", schemars(rename = "actions"))]
180 #[cfg_attr(feature = "serde", serde(rename = "actions"))]
181 pub m_actions: hkpEntitySmallArraySerializeOverrideType,
182 #[cfg_attr(feature = "json_schema", schemars(rename = "localFrame"))]
187 #[cfg_attr(feature = "serde", serde(rename = "localFrame"))]
188 pub m_localFrame: Pointer,
189 #[cfg_attr(feature = "json_schema", schemars(rename = "extendedListeners"))]
195 #[cfg_attr(feature = "serde", serde(rename = "extendedListeners"))]
196 pub m_extendedListeners: Pointer,
197 #[cfg_attr(feature = "json_schema", schemars(rename = "npData"))]
202 #[cfg_attr(feature = "serde", serde(rename = "npData"))]
203 pub m_npData: u32,
204}
205const _: () = {
206 use havok_serde as _serde;
207 impl<'a> _serde::HavokClass for hkpEntity<'a> {
208 #[inline]
209 fn name(&self) -> &'static str {
210 "hkpEntity"
211 }
212 #[inline]
213 fn signature(&self) -> _serde::__private::Signature {
214 _serde::__private::Signature::new(0xa03c774b)
215 }
216 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
217 fn deps_indexes(&self) -> Vec<usize> {
218 let mut v = Vec::new();
219 v.push(self.parent.m_world.get());
220 v.extend(self.parent.m_collidable.deps_indexes());
221 v.extend(self.parent.m_multiThreadCheck.deps_indexes());
222 v.extend(
223 self
224 .parent
225 .m_properties
226 .iter()
227 .flat_map(|class| class.deps_indexes())
228 .collect::<Vec<usize>>(),
229 );
230 v.push(self.parent.m_treeData.get());
231 v.extend(self.m_material.deps_indexes());
232 v.push(self.m_limitContactImpulseUtilAndFlag.get());
233 v.push(self.m_breakableBody.get());
234 v.extend(self.m_constraintsMaster.deps_indexes());
235 v.extend(self.m_constraintsSlave.iter().map(|ptr| ptr.get()));
236 v.push(self.m_simulationIsland.get());
237 v.extend(self.m_spuCollisionCallback.deps_indexes());
238 v.extend(self.m_motion.deps_indexes());
239 v.extend(self.m_contactListeners.deps_indexes());
240 v.extend(self.m_actions.deps_indexes());
241 v.push(self.m_localFrame.get());
242 v.push(self.m_extendedListeners.get());
243 v
244 }
245 }
246 impl<'a> _serde::Serialize for hkpEntity<'a> {
247 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
248 where
249 S: _serde::ser::Serializer,
250 {
251 let class_meta = self
252 .__ptr
253 .map(|name| (name, _serde::__private::Signature::new(0xa03c774b)));
254 let mut serializer = __serializer
255 .serialize_struct("hkpEntity", class_meta, (544u64, 720u64))?;
256 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
257 serializer
258 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
259 serializer
260 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
261 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
262 serializer.skip_field("world", &self.parent.m_world)?;
263 serializer.serialize_field("userData", &self.parent.m_userData)?;
264 serializer.serialize_field("collidable", &self.parent.m_collidable)?;
265 serializer
266 .serialize_field("multiThreadCheck", &self.parent.m_multiThreadCheck)?;
267 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
268 serializer.serialize_field("name", &self.parent.m_name)?;
269 serializer
270 .serialize_array_field(
271 "properties",
272 &self.parent.m_properties,
273 TypeSize::Struct {
274 size_x86: 16u64,
275 size_x86_64: 16u64,
276 },
277 )?;
278 serializer.skip_field("treeData", &self.parent.m_treeData)?;
279 serializer.serialize_field("material", &self.m_material)?;
280 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
281 serializer
282 .skip_field(
283 "limitContactImpulseUtilAndFlag",
284 &self.m_limitContactImpulseUtilAndFlag,
285 )?;
286 serializer.serialize_field("damageMultiplier", &self.m_damageMultiplier)?;
287 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
288 serializer.skip_field("breakableBody", &self.m_breakableBody)?;
289 serializer.skip_field("solverData", &self.m_solverData)?;
290 serializer.serialize_field("storageIndex", &self.m_storageIndex)?;
291 serializer
292 .serialize_field(
293 "contactPointCallbackDelay",
294 &self.m_contactPointCallbackDelay,
295 )?;
296 serializer.skip_field("constraintsMaster", &self.m_constraintsMaster)?;
297 serializer
298 .skip_array_field(
299 "constraintsSlave",
300 &self.m_constraintsSlave,
301 TypeSize::NonPtr,
302 )?;
303 serializer
304 .skip_array_field(
305 "constraintRuntime",
306 &self.m_constraintRuntime,
307 TypeSize::NonPtr,
308 )?;
309 serializer.skip_field("simulationIsland", &self.m_simulationIsland)?;
310 serializer.serialize_field("autoRemoveLevel", &self.m_autoRemoveLevel)?;
311 serializer
312 .serialize_field(
313 "numShapeKeysInContactPointProperties",
314 &self.m_numShapeKeysInContactPointProperties,
315 )?;
316 serializer
317 .serialize_field(
318 "responseModifierFlags",
319 &self.m_responseModifierFlags,
320 )?;
321 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
322 serializer.serialize_field("uid", &self.m_uid)?;
323 serializer
324 .serialize_field("spuCollisionCallback", &self.m_spuCollisionCallback)?;
325 serializer.serialize_field("motion", &self.m_motion)?;
326 serializer.skip_field("contactListeners", &self.m_contactListeners)?;
327 serializer.skip_field("actions", &self.m_actions)?;
328 serializer.serialize_field("localFrame", &self.m_localFrame)?;
329 serializer.skip_field("extendedListeners", &self.m_extendedListeners)?;
330 serializer.serialize_field("npData", &self.m_npData)?;
331 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 12usize].as_slice())?;
332 serializer.end()
333 }
334 }
335};
336#[doc(hidden)]
337#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
338const _: () = {
339 use havok_serde as _serde;
340 #[automatically_derived]
341 impl<'de> _serde::Deserialize<'de> for hkpEntity<'de> {
342 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
343 where
344 __D: _serde::Deserializer<'de>,
345 {
346 #[allow(non_camel_case_types)]
347 enum __Field {
348 m_userData,
349 m_collidable,
350 m_multiThreadCheck,
351 m_name,
352 m_properties,
353 m_material,
354 m_damageMultiplier,
355 m_storageIndex,
356 m_contactPointCallbackDelay,
357 m_autoRemoveLevel,
358 m_numShapeKeysInContactPointProperties,
359 m_responseModifierFlags,
360 m_uid,
361 m_spuCollisionCallback,
362 m_motion,
363 m_localFrame,
364 m_npData,
365 __ignore,
366 }
367 struct __FieldVisitor;
368 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
369 type Value = __Field;
370 fn expecting(
371 &self,
372 __formatter: &mut core::fmt::Formatter,
373 ) -> core::fmt::Result {
374 core::fmt::Formatter::write_str(__formatter, "field identifier")
375 }
376 #[allow(clippy::match_single_binding)]
378 #[allow(clippy::reversed_empty_ranges)]
379 #[allow(clippy::single_match)]
380 fn visit_key<__E>(
381 self,
382 __value: &str,
383 ) -> core::result::Result<Self::Value, __E>
384 where
385 __E: _serde::de::Error,
386 {
387 match __value {
388 "userData" => Ok(__Field::m_userData),
389 "collidable" => Ok(__Field::m_collidable),
390 "multiThreadCheck" => Ok(__Field::m_multiThreadCheck),
391 "name" => Ok(__Field::m_name),
392 "properties" => Ok(__Field::m_properties),
393 "material" => Ok(__Field::m_material),
394 "damageMultiplier" => Ok(__Field::m_damageMultiplier),
395 "storageIndex" => Ok(__Field::m_storageIndex),
396 "contactPointCallbackDelay" => {
397 Ok(__Field::m_contactPointCallbackDelay)
398 }
399 "autoRemoveLevel" => Ok(__Field::m_autoRemoveLevel),
400 "numShapeKeysInContactPointProperties" => {
401 Ok(__Field::m_numShapeKeysInContactPointProperties)
402 }
403 "responseModifierFlags" => Ok(__Field::m_responseModifierFlags),
404 "uid" => Ok(__Field::m_uid),
405 "spuCollisionCallback" => Ok(__Field::m_spuCollisionCallback),
406 "motion" => Ok(__Field::m_motion),
407 "localFrame" => Ok(__Field::m_localFrame),
408 "npData" => Ok(__Field::m_npData),
409 _ => Ok(__Field::__ignore),
410 }
411 }
412 }
413 impl<'de> _serde::Deserialize<'de> for __Field {
414 #[inline]
415 fn deserialize<__D>(
416 __deserializer: __D,
417 ) -> core::result::Result<Self, __D::Error>
418 where
419 __D: _serde::Deserializer<'de>,
420 {
421 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
422 }
423 }
424 struct __hkpEntityVisitor<'de> {
425 marker: _serde::__private::PhantomData<hkpEntity<'de>>,
426 lifetime: _serde::__private::PhantomData<&'de ()>,
427 }
428 #[allow(clippy::match_single_binding)]
429 #[allow(clippy::reversed_empty_ranges)]
430 #[allow(clippy::single_match)]
431 impl<'de> _serde::de::Visitor<'de> for __hkpEntityVisitor<'de> {
432 type Value = hkpEntity<'de>;
433 fn expecting(
434 &self,
435 __formatter: &mut core::fmt::Formatter,
436 ) -> core::fmt::Result {
437 core::fmt::Formatter::write_str(__formatter, "struct hkpEntity")
438 }
439 fn visit_struct_for_bytes<__A>(
440 self,
441 mut __map: __A,
442 ) -> _serde::__private::Result<Self::Value, __A::Error>
443 where
444 __A: _serde::de::MapAccess<'de>,
445 {
446 let __ptr = __A::class_ptr(&mut __map);
447 let parent = __A::parent_value(&mut __map)?;
448 let mut m_material: _serde::__private::Option<hkpMaterial> = _serde::__private::None;
449 let mut m_limitContactImpulseUtilAndFlag: _serde::__private::Option<
450 Pointer,
451 > = _serde::__private::None;
452 let mut m_damageMultiplier: _serde::__private::Option<f32> = _serde::__private::None;
453 let mut m_breakableBody: _serde::__private::Option<Pointer> = _serde::__private::None;
454 let mut m_solverData: _serde::__private::Option<u32> = _serde::__private::None;
455 let mut m_storageIndex: _serde::__private::Option<u16> = _serde::__private::None;
456 let mut m_contactPointCallbackDelay: _serde::__private::Option<
457 u16,
458 > = _serde::__private::None;
459 let mut m_constraintsMaster: _serde::__private::Option<
460 hkpEntitySmallArraySerializeOverrideType,
461 > = _serde::__private::None;
462 let mut m_constraintsSlave: _serde::__private::Option<
463 Vec<Pointer>,
464 > = _serde::__private::None;
465 let mut m_constraintRuntime: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
466 let mut m_simulationIsland: _serde::__private::Option<Pointer> = _serde::__private::None;
467 let mut m_autoRemoveLevel: _serde::__private::Option<i8> = _serde::__private::None;
468 let mut m_numShapeKeysInContactPointProperties: _serde::__private::Option<
469 u8,
470 > = _serde::__private::None;
471 let mut m_responseModifierFlags: _serde::__private::Option<u8> = _serde::__private::None;
472 let mut m_uid: _serde::__private::Option<u32> = _serde::__private::None;
473 let mut m_spuCollisionCallback: _serde::__private::Option<
474 hkpEntitySpuCollisionCallback,
475 > = _serde::__private::None;
476 let mut m_motion: _serde::__private::Option<hkpMaxSizeMotion> = _serde::__private::None;
477 let mut m_contactListeners: _serde::__private::Option<
478 hkpEntitySmallArraySerializeOverrideType,
479 > = _serde::__private::None;
480 let mut m_actions: _serde::__private::Option<
481 hkpEntitySmallArraySerializeOverrideType,
482 > = _serde::__private::None;
483 let mut m_localFrame: _serde::__private::Option<Pointer> = _serde::__private::None;
484 let mut m_extendedListeners: _serde::__private::Option<Pointer> = _serde::__private::None;
485 let mut m_npData: _serde::__private::Option<u32> = _serde::__private::None;
486 for i in 0..22usize {
487 match i {
488 0usize => {
489 if _serde::__private::Option::is_some(&m_material) {
490 return _serde::__private::Err(
491 <__A::Error as _serde::de::Error>::duplicate_field(
492 "material",
493 ),
494 );
495 }
496 m_material = _serde::__private::Some(
497 match __A::next_value::<hkpMaterial>(&mut __map) {
498 _serde::__private::Ok(__val) => __val,
499 _serde::__private::Err(__err) => {
500 return _serde::__private::Err(__err);
501 }
502 },
503 );
504 }
505 1usize => {
506 if _serde::__private::Option::is_some(
507 &m_limitContactImpulseUtilAndFlag,
508 ) {
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::duplicate_field(
511 "limitContactImpulseUtilAndFlag",
512 ),
513 );
514 }
515 __A::pad(&mut __map, 0usize, 4usize)?;
516 m_limitContactImpulseUtilAndFlag = _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 2usize => {
526 if _serde::__private::Option::is_some(&m_damageMultiplier) {
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::duplicate_field(
529 "damageMultiplier",
530 ),
531 );
532 }
533 m_damageMultiplier = _serde::__private::Some(
534 match __A::next_value::<f32>(&mut __map) {
535 _serde::__private::Ok(__val) => __val,
536 _serde::__private::Err(__err) => {
537 return _serde::__private::Err(__err);
538 }
539 },
540 );
541 }
542 3usize => {
543 if _serde::__private::Option::is_some(&m_breakableBody) {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::duplicate_field(
546 "breakableBody",
547 ),
548 );
549 }
550 __A::pad(&mut __map, 0usize, 4usize)?;
551 m_breakableBody = _serde::__private::Some(
552 match __A::next_value::<Pointer>(&mut __map) {
553 _serde::__private::Ok(__val) => __val,
554 _serde::__private::Err(__err) => {
555 return _serde::__private::Err(__err);
556 }
557 },
558 );
559 }
560 4usize => {
561 if _serde::__private::Option::is_some(&m_solverData) {
562 return _serde::__private::Err(
563 <__A::Error as _serde::de::Error>::duplicate_field(
564 "solverData",
565 ),
566 );
567 }
568 m_solverData = _serde::__private::Some(
569 match __A::next_value::<u32>(&mut __map) {
570 _serde::__private::Ok(__val) => __val,
571 _serde::__private::Err(__err) => {
572 return _serde::__private::Err(__err);
573 }
574 },
575 );
576 }
577 5usize => {
578 if _serde::__private::Option::is_some(&m_storageIndex) {
579 return _serde::__private::Err(
580 <__A::Error as _serde::de::Error>::duplicate_field(
581 "storageIndex",
582 ),
583 );
584 }
585 m_storageIndex = _serde::__private::Some(
586 match __A::next_value::<u16>(&mut __map) {
587 _serde::__private::Ok(__val) => __val,
588 _serde::__private::Err(__err) => {
589 return _serde::__private::Err(__err);
590 }
591 },
592 );
593 }
594 6usize => {
595 if _serde::__private::Option::is_some(
596 &m_contactPointCallbackDelay,
597 ) {
598 return _serde::__private::Err(
599 <__A::Error as _serde::de::Error>::duplicate_field(
600 "contactPointCallbackDelay",
601 ),
602 );
603 }
604 m_contactPointCallbackDelay = _serde::__private::Some(
605 match __A::next_value::<u16>(&mut __map) {
606 _serde::__private::Ok(__val) => __val,
607 _serde::__private::Err(__err) => {
608 return _serde::__private::Err(__err);
609 }
610 },
611 );
612 }
613 7usize => {
614 if _serde::__private::Option::is_some(
615 &m_constraintsMaster,
616 ) {
617 return _serde::__private::Err(
618 <__A::Error as _serde::de::Error>::duplicate_field(
619 "constraintsMaster",
620 ),
621 );
622 }
623 m_constraintsMaster = _serde::__private::Some(
624 match __A::next_value::<
625 hkpEntitySmallArraySerializeOverrideType,
626 >(&mut __map) {
627 _serde::__private::Ok(__val) => __val,
628 _serde::__private::Err(__err) => {
629 return _serde::__private::Err(__err);
630 }
631 },
632 );
633 }
634 8usize => {
635 if _serde::__private::Option::is_some(&m_constraintsSlave) {
636 return _serde::__private::Err(
637 <__A::Error as _serde::de::Error>::duplicate_field(
638 "constraintsSlave",
639 ),
640 );
641 }
642 m_constraintsSlave = _serde::__private::Some(
643 match __A::next_value::<Vec<Pointer>>(&mut __map) {
644 _serde::__private::Ok(__val) => __val,
645 _serde::__private::Err(__err) => {
646 return _serde::__private::Err(__err);
647 }
648 },
649 );
650 }
651 9usize => {
652 if _serde::__private::Option::is_some(
653 &m_constraintRuntime,
654 ) {
655 return _serde::__private::Err(
656 <__A::Error as _serde::de::Error>::duplicate_field(
657 "constraintRuntime",
658 ),
659 );
660 }
661 m_constraintRuntime = _serde::__private::Some(
662 match __A::next_value::<Vec<u8>>(&mut __map) {
663 _serde::__private::Ok(__val) => __val,
664 _serde::__private::Err(__err) => {
665 return _serde::__private::Err(__err);
666 }
667 },
668 );
669 }
670 10usize => {
671 if _serde::__private::Option::is_some(&m_simulationIsland) {
672 return _serde::__private::Err(
673 <__A::Error as _serde::de::Error>::duplicate_field(
674 "simulationIsland",
675 ),
676 );
677 }
678 m_simulationIsland = _serde::__private::Some(
679 match __A::next_value::<Pointer>(&mut __map) {
680 _serde::__private::Ok(__val) => __val,
681 _serde::__private::Err(__err) => {
682 return _serde::__private::Err(__err);
683 }
684 },
685 );
686 }
687 11usize => {
688 if _serde::__private::Option::is_some(&m_autoRemoveLevel) {
689 return _serde::__private::Err(
690 <__A::Error as _serde::de::Error>::duplicate_field(
691 "autoRemoveLevel",
692 ),
693 );
694 }
695 m_autoRemoveLevel = _serde::__private::Some(
696 match __A::next_value::<i8>(&mut __map) {
697 _serde::__private::Ok(__val) => __val,
698 _serde::__private::Err(__err) => {
699 return _serde::__private::Err(__err);
700 }
701 },
702 );
703 }
704 12usize => {
705 if _serde::__private::Option::is_some(
706 &m_numShapeKeysInContactPointProperties,
707 ) {
708 return _serde::__private::Err(
709 <__A::Error as _serde::de::Error>::duplicate_field(
710 "numShapeKeysInContactPointProperties",
711 ),
712 );
713 }
714 m_numShapeKeysInContactPointProperties = _serde::__private::Some(
715 match __A::next_value::<u8>(&mut __map) {
716 _serde::__private::Ok(__val) => __val,
717 _serde::__private::Err(__err) => {
718 return _serde::__private::Err(__err);
719 }
720 },
721 );
722 }
723 13usize => {
724 if _serde::__private::Option::is_some(
725 &m_responseModifierFlags,
726 ) {
727 return _serde::__private::Err(
728 <__A::Error as _serde::de::Error>::duplicate_field(
729 "responseModifierFlags",
730 ),
731 );
732 }
733 m_responseModifierFlags = _serde::__private::Some(
734 match __A::next_value::<u8>(&mut __map) {
735 _serde::__private::Ok(__val) => __val,
736 _serde::__private::Err(__err) => {
737 return _serde::__private::Err(__err);
738 }
739 },
740 );
741 }
742 14usize => {
743 if _serde::__private::Option::is_some(&m_uid) {
744 return _serde::__private::Err(
745 <__A::Error as _serde::de::Error>::duplicate_field("uid"),
746 );
747 }
748 __A::pad(&mut __map, 1usize, 1usize)?;
749 m_uid = _serde::__private::Some(
750 match __A::next_value::<u32>(&mut __map) {
751 _serde::__private::Ok(__val) => __val,
752 _serde::__private::Err(__err) => {
753 return _serde::__private::Err(__err);
754 }
755 },
756 );
757 }
758 15usize => {
759 if _serde::__private::Option::is_some(
760 &m_spuCollisionCallback,
761 ) {
762 return _serde::__private::Err(
763 <__A::Error as _serde::de::Error>::duplicate_field(
764 "spuCollisionCallback",
765 ),
766 );
767 }
768 m_spuCollisionCallback = _serde::__private::Some(
769 match __A::next_value::<
770 hkpEntitySpuCollisionCallback,
771 >(&mut __map) {
772 _serde::__private::Ok(__val) => __val,
773 _serde::__private::Err(__err) => {
774 return _serde::__private::Err(__err);
775 }
776 },
777 );
778 }
779 16usize => {
780 if _serde::__private::Option::is_some(&m_motion) {
781 return _serde::__private::Err(
782 <__A::Error as _serde::de::Error>::duplicate_field("motion"),
783 );
784 }
785 m_motion = _serde::__private::Some(
786 match __A::next_value::<hkpMaxSizeMotion>(&mut __map) {
787 _serde::__private::Ok(__val) => __val,
788 _serde::__private::Err(__err) => {
789 return _serde::__private::Err(__err);
790 }
791 },
792 );
793 }
794 17usize => {
795 if _serde::__private::Option::is_some(&m_contactListeners) {
796 return _serde::__private::Err(
797 <__A::Error as _serde::de::Error>::duplicate_field(
798 "contactListeners",
799 ),
800 );
801 }
802 m_contactListeners = _serde::__private::Some(
803 match __A::next_value::<
804 hkpEntitySmallArraySerializeOverrideType,
805 >(&mut __map) {
806 _serde::__private::Ok(__val) => __val,
807 _serde::__private::Err(__err) => {
808 return _serde::__private::Err(__err);
809 }
810 },
811 );
812 }
813 18usize => {
814 if _serde::__private::Option::is_some(&m_actions) {
815 return _serde::__private::Err(
816 <__A::Error as _serde::de::Error>::duplicate_field(
817 "actions",
818 ),
819 );
820 }
821 m_actions = _serde::__private::Some(
822 match __A::next_value::<
823 hkpEntitySmallArraySerializeOverrideType,
824 >(&mut __map) {
825 _serde::__private::Ok(__val) => __val,
826 _serde::__private::Err(__err) => {
827 return _serde::__private::Err(__err);
828 }
829 },
830 );
831 }
832 19usize => {
833 if _serde::__private::Option::is_some(&m_localFrame) {
834 return _serde::__private::Err(
835 <__A::Error as _serde::de::Error>::duplicate_field(
836 "localFrame",
837 ),
838 );
839 }
840 m_localFrame = _serde::__private::Some(
841 match __A::next_value::<Pointer>(&mut __map) {
842 _serde::__private::Ok(__val) => __val,
843 _serde::__private::Err(__err) => {
844 return _serde::__private::Err(__err);
845 }
846 },
847 );
848 }
849 20usize => {
850 if _serde::__private::Option::is_some(
851 &m_extendedListeners,
852 ) {
853 return _serde::__private::Err(
854 <__A::Error as _serde::de::Error>::duplicate_field(
855 "extendedListeners",
856 ),
857 );
858 }
859 m_extendedListeners = _serde::__private::Some(
860 match __A::next_value::<Pointer>(&mut __map) {
861 _serde::__private::Ok(__val) => __val,
862 _serde::__private::Err(__err) => {
863 return _serde::__private::Err(__err);
864 }
865 },
866 );
867 }
868 21usize => {
869 if _serde::__private::Option::is_some(&m_npData) {
870 return _serde::__private::Err(
871 <__A::Error as _serde::de::Error>::duplicate_field("npData"),
872 );
873 }
874 m_npData = _serde::__private::Some(
875 match __A::next_value::<u32>(&mut __map) {
876 _serde::__private::Ok(__val) => __val,
877 _serde::__private::Err(__err) => {
878 return _serde::__private::Err(__err);
879 }
880 },
881 );
882 }
883 _ => {}
884 }
885 }
886 __A::pad(&mut __map, 4usize, 12usize)?;
887 let m_material = match m_material {
888 _serde::__private::Some(__field) => __field,
889 _serde::__private::None => {
890 return _serde::__private::Err(
891 <__A::Error as _serde::de::Error>::missing_field("material"),
892 );
893 }
894 };
895 let m_limitContactImpulseUtilAndFlag = match m_limitContactImpulseUtilAndFlag {
896 _serde::__private::Some(__field) => __field,
897 _serde::__private::None => {
898 return _serde::__private::Err(
899 <__A::Error as _serde::de::Error>::missing_field(
900 "limitContactImpulseUtilAndFlag",
901 ),
902 );
903 }
904 };
905 let m_damageMultiplier = match m_damageMultiplier {
906 _serde::__private::Some(__field) => __field,
907 _serde::__private::None => {
908 return _serde::__private::Err(
909 <__A::Error as _serde::de::Error>::missing_field(
910 "damageMultiplier",
911 ),
912 );
913 }
914 };
915 let m_breakableBody = match m_breakableBody {
916 _serde::__private::Some(__field) => __field,
917 _serde::__private::None => {
918 return _serde::__private::Err(
919 <__A::Error as _serde::de::Error>::missing_field(
920 "breakableBody",
921 ),
922 );
923 }
924 };
925 let m_solverData = match m_solverData {
926 _serde::__private::Some(__field) => __field,
927 _serde::__private::None => {
928 return _serde::__private::Err(
929 <__A::Error as _serde::de::Error>::missing_field(
930 "solverData",
931 ),
932 );
933 }
934 };
935 let m_storageIndex = match m_storageIndex {
936 _serde::__private::Some(__field) => __field,
937 _serde::__private::None => {
938 return _serde::__private::Err(
939 <__A::Error as _serde::de::Error>::missing_field(
940 "storageIndex",
941 ),
942 );
943 }
944 };
945 let m_contactPointCallbackDelay = match m_contactPointCallbackDelay {
946 _serde::__private::Some(__field) => __field,
947 _serde::__private::None => {
948 return _serde::__private::Err(
949 <__A::Error as _serde::de::Error>::missing_field(
950 "contactPointCallbackDelay",
951 ),
952 );
953 }
954 };
955 let m_constraintsMaster = match m_constraintsMaster {
956 _serde::__private::Some(__field) => __field,
957 _serde::__private::None => {
958 return _serde::__private::Err(
959 <__A::Error as _serde::de::Error>::missing_field(
960 "constraintsMaster",
961 ),
962 );
963 }
964 };
965 let m_constraintsSlave = match m_constraintsSlave {
966 _serde::__private::Some(__field) => __field,
967 _serde::__private::None => {
968 return _serde::__private::Err(
969 <__A::Error as _serde::de::Error>::missing_field(
970 "constraintsSlave",
971 ),
972 );
973 }
974 };
975 let m_constraintRuntime = match m_constraintRuntime {
976 _serde::__private::Some(__field) => __field,
977 _serde::__private::None => {
978 return _serde::__private::Err(
979 <__A::Error as _serde::de::Error>::missing_field(
980 "constraintRuntime",
981 ),
982 );
983 }
984 };
985 let m_simulationIsland = match m_simulationIsland {
986 _serde::__private::Some(__field) => __field,
987 _serde::__private::None => {
988 return _serde::__private::Err(
989 <__A::Error as _serde::de::Error>::missing_field(
990 "simulationIsland",
991 ),
992 );
993 }
994 };
995 let m_autoRemoveLevel = match m_autoRemoveLevel {
996 _serde::__private::Some(__field) => __field,
997 _serde::__private::None => {
998 return _serde::__private::Err(
999 <__A::Error as _serde::de::Error>::missing_field(
1000 "autoRemoveLevel",
1001 ),
1002 );
1003 }
1004 };
1005 let m_numShapeKeysInContactPointProperties = match m_numShapeKeysInContactPointProperties {
1006 _serde::__private::Some(__field) => __field,
1007 _serde::__private::None => {
1008 return _serde::__private::Err(
1009 <__A::Error as _serde::de::Error>::missing_field(
1010 "numShapeKeysInContactPointProperties",
1011 ),
1012 );
1013 }
1014 };
1015 let m_responseModifierFlags = match m_responseModifierFlags {
1016 _serde::__private::Some(__field) => __field,
1017 _serde::__private::None => {
1018 return _serde::__private::Err(
1019 <__A::Error as _serde::de::Error>::missing_field(
1020 "responseModifierFlags",
1021 ),
1022 );
1023 }
1024 };
1025 let m_uid = match m_uid {
1026 _serde::__private::Some(__field) => __field,
1027 _serde::__private::None => {
1028 return _serde::__private::Err(
1029 <__A::Error as _serde::de::Error>::missing_field("uid"),
1030 );
1031 }
1032 };
1033 let m_spuCollisionCallback = match m_spuCollisionCallback {
1034 _serde::__private::Some(__field) => __field,
1035 _serde::__private::None => {
1036 return _serde::__private::Err(
1037 <__A::Error as _serde::de::Error>::missing_field(
1038 "spuCollisionCallback",
1039 ),
1040 );
1041 }
1042 };
1043 let m_motion = match m_motion {
1044 _serde::__private::Some(__field) => __field,
1045 _serde::__private::None => {
1046 return _serde::__private::Err(
1047 <__A::Error as _serde::de::Error>::missing_field("motion"),
1048 );
1049 }
1050 };
1051 let m_contactListeners = match m_contactListeners {
1052 _serde::__private::Some(__field) => __field,
1053 _serde::__private::None => {
1054 return _serde::__private::Err(
1055 <__A::Error as _serde::de::Error>::missing_field(
1056 "contactListeners",
1057 ),
1058 );
1059 }
1060 };
1061 let m_actions = match m_actions {
1062 _serde::__private::Some(__field) => __field,
1063 _serde::__private::None => {
1064 return _serde::__private::Err(
1065 <__A::Error as _serde::de::Error>::missing_field("actions"),
1066 );
1067 }
1068 };
1069 let m_localFrame = match m_localFrame {
1070 _serde::__private::Some(__field) => __field,
1071 _serde::__private::None => {
1072 return _serde::__private::Err(
1073 <__A::Error as _serde::de::Error>::missing_field(
1074 "localFrame",
1075 ),
1076 );
1077 }
1078 };
1079 let m_extendedListeners = match m_extendedListeners {
1080 _serde::__private::Some(__field) => __field,
1081 _serde::__private::None => {
1082 return _serde::__private::Err(
1083 <__A::Error as _serde::de::Error>::missing_field(
1084 "extendedListeners",
1085 ),
1086 );
1087 }
1088 };
1089 let m_npData = match m_npData {
1090 _serde::__private::Some(__field) => __field,
1091 _serde::__private::None => {
1092 return _serde::__private::Err(
1093 <__A::Error as _serde::de::Error>::missing_field("npData"),
1094 );
1095 }
1096 };
1097 _serde::__private::Ok(hkpEntity {
1098 __ptr,
1099 parent,
1100 m_material,
1101 m_limitContactImpulseUtilAndFlag,
1102 m_damageMultiplier,
1103 m_breakableBody,
1104 m_solverData,
1105 m_storageIndex,
1106 m_contactPointCallbackDelay,
1107 m_constraintsMaster,
1108 m_constraintsSlave,
1109 m_constraintRuntime,
1110 m_simulationIsland,
1111 m_autoRemoveLevel,
1112 m_numShapeKeysInContactPointProperties,
1113 m_responseModifierFlags,
1114 m_uid,
1115 m_spuCollisionCallback,
1116 m_motion,
1117 m_contactListeners,
1118 m_actions,
1119 m_localFrame,
1120 m_extendedListeners,
1121 m_npData,
1122 })
1123 }
1124 #[allow(clippy::manual_unwrap_or_default)]
1125 fn visit_struct<__A>(
1126 self,
1127 mut __map: __A,
1128 ) -> _serde::__private::Result<Self::Value, __A::Error>
1129 where
1130 __A: _serde::de::MapAccess<'de>,
1131 {
1132 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1133 let mut m_collidable: _serde::__private::Option<
1134 hkpLinkedCollidable,
1135 > = _serde::__private::None;
1136 let mut m_multiThreadCheck: _serde::__private::Option<
1137 hkMultiThreadCheck,
1138 > = _serde::__private::None;
1139 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1140 let mut m_properties: _serde::__private::Option<Vec<hkpProperty>> = _serde::__private::None;
1141 let mut m_material: _serde::__private::Option<hkpMaterial> = _serde::__private::None;
1142 let mut m_damageMultiplier: _serde::__private::Option<f32> = _serde::__private::None;
1143 let mut m_storageIndex: _serde::__private::Option<u16> = _serde::__private::None;
1144 let mut m_contactPointCallbackDelay: _serde::__private::Option<
1145 u16,
1146 > = _serde::__private::None;
1147 let mut m_autoRemoveLevel: _serde::__private::Option<i8> = _serde::__private::None;
1148 let mut m_numShapeKeysInContactPointProperties: _serde::__private::Option<
1149 u8,
1150 > = _serde::__private::None;
1151 let mut m_responseModifierFlags: _serde::__private::Option<u8> = _serde::__private::None;
1152 let mut m_uid: _serde::__private::Option<u32> = _serde::__private::None;
1153 let mut m_spuCollisionCallback: _serde::__private::Option<
1154 hkpEntitySpuCollisionCallback,
1155 > = _serde::__private::None;
1156 let mut m_motion: _serde::__private::Option<hkpMaxSizeMotion> = _serde::__private::None;
1157 let mut m_localFrame: _serde::__private::Option<Pointer> = _serde::__private::None;
1158 let mut m_npData: _serde::__private::Option<u32> = _serde::__private::None;
1159 while let _serde::__private::Some(__key) = {
1160 __A::next_key::<__Field>(&mut __map)?
1161 } {
1162 match __key {
1163 __Field::m_userData => {
1164 #[cfg(
1165 any(feature = "strict", feature = "ignore_duplicates")
1166 )]
1167 if _serde::__private::Option::is_some(&m_userData) {
1168 #[cfg(feature = "ignore_duplicates")]
1169 {
1170 __A::skip_value(&mut __map)?;
1171 continue;
1172 }
1173 #[cfg(feature = "strict")]
1174 return _serde::__private::Err(
1175 <__A::Error as _serde::de::Error>::duplicate_field(
1176 "userData",
1177 ),
1178 );
1179 }
1180 m_userData = _serde::__private::Some(
1181 match __A::next_value::<Ulong>(&mut __map) {
1182 _serde::__private::Ok(__val) => __val,
1183 _serde::__private::Err(__err) => {
1184 return _serde::__private::Err(__err);
1185 }
1186 },
1187 );
1188 }
1189 __Field::m_collidable => {
1190 #[cfg(
1191 any(feature = "strict", feature = "ignore_duplicates")
1192 )]
1193 if _serde::__private::Option::is_some(&m_collidable) {
1194 #[cfg(feature = "ignore_duplicates")]
1195 {
1196 __A::skip_value(&mut __map)?;
1197 continue;
1198 }
1199 #[cfg(feature = "strict")]
1200 return _serde::__private::Err(
1201 <__A::Error as _serde::de::Error>::duplicate_field(
1202 "collidable",
1203 ),
1204 );
1205 }
1206 m_collidable = _serde::__private::Some(
1207 match __A::next_value::<hkpLinkedCollidable>(&mut __map) {
1208 _serde::__private::Ok(__val) => __val,
1209 _serde::__private::Err(__err) => {
1210 return _serde::__private::Err(__err);
1211 }
1212 },
1213 );
1214 }
1215 __Field::m_multiThreadCheck => {
1216 #[cfg(
1217 any(feature = "strict", feature = "ignore_duplicates")
1218 )]
1219 if _serde::__private::Option::is_some(&m_multiThreadCheck) {
1220 #[cfg(feature = "ignore_duplicates")]
1221 {
1222 __A::skip_value(&mut __map)?;
1223 continue;
1224 }
1225 #[cfg(feature = "strict")]
1226 return _serde::__private::Err(
1227 <__A::Error as _serde::de::Error>::duplicate_field(
1228 "multiThreadCheck",
1229 ),
1230 );
1231 }
1232 m_multiThreadCheck = _serde::__private::Some(
1233 match __A::next_value::<hkMultiThreadCheck>(&mut __map) {
1234 _serde::__private::Ok(__val) => __val,
1235 _serde::__private::Err(__err) => {
1236 return _serde::__private::Err(__err);
1237 }
1238 },
1239 );
1240 }
1241 __Field::m_name => {
1242 #[cfg(
1243 any(feature = "strict", feature = "ignore_duplicates")
1244 )]
1245 if _serde::__private::Option::is_some(&m_name) {
1246 #[cfg(feature = "ignore_duplicates")]
1247 {
1248 __A::skip_value(&mut __map)?;
1249 continue;
1250 }
1251 #[cfg(feature = "strict")]
1252 return _serde::__private::Err(
1253 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1254 );
1255 }
1256 m_name = _serde::__private::Some(
1257 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1258 _serde::__private::Ok(__val) => __val,
1259 _serde::__private::Err(__err) => {
1260 return _serde::__private::Err(__err);
1261 }
1262 },
1263 );
1264 }
1265 __Field::m_properties => {
1266 #[cfg(
1267 any(feature = "strict", feature = "ignore_duplicates")
1268 )]
1269 if _serde::__private::Option::is_some(&m_properties) {
1270 #[cfg(feature = "ignore_duplicates")]
1271 {
1272 __A::skip_value(&mut __map)?;
1273 continue;
1274 }
1275 #[cfg(feature = "strict")]
1276 return _serde::__private::Err(
1277 <__A::Error as _serde::de::Error>::duplicate_field(
1278 "properties",
1279 ),
1280 );
1281 }
1282 m_properties = _serde::__private::Some(
1283 match __A::next_value::<Vec<hkpProperty>>(&mut __map) {
1284 _serde::__private::Ok(__val) => __val,
1285 _serde::__private::Err(__err) => {
1286 return _serde::__private::Err(__err);
1287 }
1288 },
1289 );
1290 }
1291 __Field::m_material => {
1292 #[cfg(
1293 any(feature = "strict", feature = "ignore_duplicates")
1294 )]
1295 if _serde::__private::Option::is_some(&m_material) {
1296 #[cfg(feature = "ignore_duplicates")]
1297 {
1298 __A::skip_value(&mut __map)?;
1299 continue;
1300 }
1301 #[cfg(feature = "strict")]
1302 return _serde::__private::Err(
1303 <__A::Error as _serde::de::Error>::duplicate_field(
1304 "material",
1305 ),
1306 );
1307 }
1308 m_material = _serde::__private::Some(
1309 match __A::next_value::<hkpMaterial>(&mut __map) {
1310 _serde::__private::Ok(__val) => __val,
1311 _serde::__private::Err(__err) => {
1312 return _serde::__private::Err(__err);
1313 }
1314 },
1315 );
1316 }
1317 __Field::m_damageMultiplier => {
1318 #[cfg(
1319 any(feature = "strict", feature = "ignore_duplicates")
1320 )]
1321 if _serde::__private::Option::is_some(&m_damageMultiplier) {
1322 #[cfg(feature = "ignore_duplicates")]
1323 {
1324 __A::skip_value(&mut __map)?;
1325 continue;
1326 }
1327 #[cfg(feature = "strict")]
1328 return _serde::__private::Err(
1329 <__A::Error as _serde::de::Error>::duplicate_field(
1330 "damageMultiplier",
1331 ),
1332 );
1333 }
1334 m_damageMultiplier = _serde::__private::Some(
1335 match __A::next_value::<f32>(&mut __map) {
1336 _serde::__private::Ok(__val) => __val,
1337 _serde::__private::Err(__err) => {
1338 return _serde::__private::Err(__err);
1339 }
1340 },
1341 );
1342 }
1343 __Field::m_storageIndex => {
1344 #[cfg(
1345 any(feature = "strict", feature = "ignore_duplicates")
1346 )]
1347 if _serde::__private::Option::is_some(&m_storageIndex) {
1348 #[cfg(feature = "ignore_duplicates")]
1349 {
1350 __A::skip_value(&mut __map)?;
1351 continue;
1352 }
1353 #[cfg(feature = "strict")]
1354 return _serde::__private::Err(
1355 <__A::Error as _serde::de::Error>::duplicate_field(
1356 "storageIndex",
1357 ),
1358 );
1359 }
1360 m_storageIndex = _serde::__private::Some(
1361 match __A::next_value::<u16>(&mut __map) {
1362 _serde::__private::Ok(__val) => __val,
1363 _serde::__private::Err(__err) => {
1364 return _serde::__private::Err(__err);
1365 }
1366 },
1367 );
1368 }
1369 __Field::m_contactPointCallbackDelay => {
1370 #[cfg(
1371 any(feature = "strict", feature = "ignore_duplicates")
1372 )]
1373 if _serde::__private::Option::is_some(
1374 &m_contactPointCallbackDelay,
1375 ) {
1376 #[cfg(feature = "ignore_duplicates")]
1377 {
1378 __A::skip_value(&mut __map)?;
1379 continue;
1380 }
1381 #[cfg(feature = "strict")]
1382 return _serde::__private::Err(
1383 <__A::Error as _serde::de::Error>::duplicate_field(
1384 "contactPointCallbackDelay",
1385 ),
1386 );
1387 }
1388 m_contactPointCallbackDelay = _serde::__private::Some(
1389 match __A::next_value::<u16>(&mut __map) {
1390 _serde::__private::Ok(__val) => __val,
1391 _serde::__private::Err(__err) => {
1392 return _serde::__private::Err(__err);
1393 }
1394 },
1395 );
1396 }
1397 __Field::m_autoRemoveLevel => {
1398 #[cfg(
1399 any(feature = "strict", feature = "ignore_duplicates")
1400 )]
1401 if _serde::__private::Option::is_some(&m_autoRemoveLevel) {
1402 #[cfg(feature = "ignore_duplicates")]
1403 {
1404 __A::skip_value(&mut __map)?;
1405 continue;
1406 }
1407 #[cfg(feature = "strict")]
1408 return _serde::__private::Err(
1409 <__A::Error as _serde::de::Error>::duplicate_field(
1410 "autoRemoveLevel",
1411 ),
1412 );
1413 }
1414 m_autoRemoveLevel = _serde::__private::Some(
1415 match __A::next_value::<i8>(&mut __map) {
1416 _serde::__private::Ok(__val) => __val,
1417 _serde::__private::Err(__err) => {
1418 return _serde::__private::Err(__err);
1419 }
1420 },
1421 );
1422 }
1423 __Field::m_numShapeKeysInContactPointProperties => {
1424 #[cfg(
1425 any(feature = "strict", feature = "ignore_duplicates")
1426 )]
1427 if _serde::__private::Option::is_some(
1428 &m_numShapeKeysInContactPointProperties,
1429 ) {
1430 #[cfg(feature = "ignore_duplicates")]
1431 {
1432 __A::skip_value(&mut __map)?;
1433 continue;
1434 }
1435 #[cfg(feature = "strict")]
1436 return _serde::__private::Err(
1437 <__A::Error as _serde::de::Error>::duplicate_field(
1438 "numShapeKeysInContactPointProperties",
1439 ),
1440 );
1441 }
1442 m_numShapeKeysInContactPointProperties = _serde::__private::Some(
1443 match __A::next_value::<u8>(&mut __map) {
1444 _serde::__private::Ok(__val) => __val,
1445 _serde::__private::Err(__err) => {
1446 return _serde::__private::Err(__err);
1447 }
1448 },
1449 );
1450 }
1451 __Field::m_responseModifierFlags => {
1452 #[cfg(
1453 any(feature = "strict", feature = "ignore_duplicates")
1454 )]
1455 if _serde::__private::Option::is_some(
1456 &m_responseModifierFlags,
1457 ) {
1458 #[cfg(feature = "ignore_duplicates")]
1459 {
1460 __A::skip_value(&mut __map)?;
1461 continue;
1462 }
1463 #[cfg(feature = "strict")]
1464 return _serde::__private::Err(
1465 <__A::Error as _serde::de::Error>::duplicate_field(
1466 "responseModifierFlags",
1467 ),
1468 );
1469 }
1470 m_responseModifierFlags = _serde::__private::Some(
1471 match __A::next_value::<u8>(&mut __map) {
1472 _serde::__private::Ok(__val) => __val,
1473 _serde::__private::Err(__err) => {
1474 return _serde::__private::Err(__err);
1475 }
1476 },
1477 );
1478 }
1479 __Field::m_uid => {
1480 #[cfg(
1481 any(feature = "strict", feature = "ignore_duplicates")
1482 )]
1483 if _serde::__private::Option::is_some(&m_uid) {
1484 #[cfg(feature = "ignore_duplicates")]
1485 {
1486 __A::skip_value(&mut __map)?;
1487 continue;
1488 }
1489 #[cfg(feature = "strict")]
1490 return _serde::__private::Err(
1491 <__A::Error as _serde::de::Error>::duplicate_field("uid"),
1492 );
1493 }
1494 m_uid = _serde::__private::Some(
1495 match __A::next_value::<u32>(&mut __map) {
1496 _serde::__private::Ok(__val) => __val,
1497 _serde::__private::Err(__err) => {
1498 return _serde::__private::Err(__err);
1499 }
1500 },
1501 );
1502 }
1503 __Field::m_spuCollisionCallback => {
1504 #[cfg(
1505 any(feature = "strict", feature = "ignore_duplicates")
1506 )]
1507 if _serde::__private::Option::is_some(
1508 &m_spuCollisionCallback,
1509 ) {
1510 #[cfg(feature = "ignore_duplicates")]
1511 {
1512 __A::skip_value(&mut __map)?;
1513 continue;
1514 }
1515 #[cfg(feature = "strict")]
1516 return _serde::__private::Err(
1517 <__A::Error as _serde::de::Error>::duplicate_field(
1518 "spuCollisionCallback",
1519 ),
1520 );
1521 }
1522 m_spuCollisionCallback = _serde::__private::Some(
1523 match __A::next_value::<
1524 hkpEntitySpuCollisionCallback,
1525 >(&mut __map) {
1526 _serde::__private::Ok(__val) => __val,
1527 _serde::__private::Err(__err) => {
1528 return _serde::__private::Err(__err);
1529 }
1530 },
1531 );
1532 }
1533 __Field::m_motion => {
1534 #[cfg(
1535 any(feature = "strict", feature = "ignore_duplicates")
1536 )]
1537 if _serde::__private::Option::is_some(&m_motion) {
1538 #[cfg(feature = "ignore_duplicates")]
1539 {
1540 __A::skip_value(&mut __map)?;
1541 continue;
1542 }
1543 #[cfg(feature = "strict")]
1544 return _serde::__private::Err(
1545 <__A::Error as _serde::de::Error>::duplicate_field("motion"),
1546 );
1547 }
1548 m_motion = _serde::__private::Some(
1549 match __A::next_value::<hkpMaxSizeMotion>(&mut __map) {
1550 _serde::__private::Ok(__val) => __val,
1551 _serde::__private::Err(__err) => {
1552 return _serde::__private::Err(__err);
1553 }
1554 },
1555 );
1556 }
1557 __Field::m_localFrame => {
1558 #[cfg(
1559 any(feature = "strict", feature = "ignore_duplicates")
1560 )]
1561 if _serde::__private::Option::is_some(&m_localFrame) {
1562 #[cfg(feature = "ignore_duplicates")]
1563 {
1564 __A::skip_value(&mut __map)?;
1565 continue;
1566 }
1567 #[cfg(feature = "strict")]
1568 return _serde::__private::Err(
1569 <__A::Error as _serde::de::Error>::duplicate_field(
1570 "localFrame",
1571 ),
1572 );
1573 }
1574 m_localFrame = _serde::__private::Some(
1575 match __A::next_value::<Pointer>(&mut __map) {
1576 _serde::__private::Ok(__val) => __val,
1577 _serde::__private::Err(__err) => {
1578 return _serde::__private::Err(__err);
1579 }
1580 },
1581 );
1582 }
1583 __Field::m_npData => {
1584 #[cfg(
1585 any(feature = "strict", feature = "ignore_duplicates")
1586 )]
1587 if _serde::__private::Option::is_some(&m_npData) {
1588 #[cfg(feature = "ignore_duplicates")]
1589 {
1590 __A::skip_value(&mut __map)?;
1591 continue;
1592 }
1593 #[cfg(feature = "strict")]
1594 return _serde::__private::Err(
1595 <__A::Error as _serde::de::Error>::duplicate_field("npData"),
1596 );
1597 }
1598 m_npData = _serde::__private::Some(
1599 match __A::next_value::<u32>(&mut __map) {
1600 _serde::__private::Ok(__val) => __val,
1601 _serde::__private::Err(__err) => {
1602 return _serde::__private::Err(__err);
1603 }
1604 },
1605 );
1606 }
1607 _ => __A::skip_value(&mut __map)?,
1608 }
1609 }
1610 let m_userData = match m_userData {
1611 _serde::__private::Some(__field) => __field,
1612 _serde::__private::None => {
1613 #[cfg(feature = "strict")]
1614 return _serde::__private::Err(
1615 <__A::Error as _serde::de::Error>::missing_field("userData"),
1616 );
1617 #[cfg(not(feature = "strict"))] Default::default()
1618 }
1619 };
1620 let m_collidable = match m_collidable {
1621 _serde::__private::Some(__field) => __field,
1622 _serde::__private::None => {
1623 #[cfg(feature = "strict")]
1624 return _serde::__private::Err(
1625 <__A::Error as _serde::de::Error>::missing_field(
1626 "collidable",
1627 ),
1628 );
1629 #[cfg(not(feature = "strict"))] Default::default()
1630 }
1631 };
1632 let m_multiThreadCheck = match m_multiThreadCheck {
1633 _serde::__private::Some(__field) => __field,
1634 _serde::__private::None => {
1635 #[cfg(feature = "strict")]
1636 return _serde::__private::Err(
1637 <__A::Error as _serde::de::Error>::missing_field(
1638 "multiThreadCheck",
1639 ),
1640 );
1641 #[cfg(not(feature = "strict"))] Default::default()
1642 }
1643 };
1644 let m_name = match m_name {
1645 _serde::__private::Some(__field) => __field,
1646 _serde::__private::None => {
1647 #[cfg(feature = "strict")]
1648 return _serde::__private::Err(
1649 <__A::Error as _serde::de::Error>::missing_field("name"),
1650 );
1651 #[cfg(not(feature = "strict"))] Default::default()
1652 }
1653 };
1654 let m_properties = match m_properties {
1655 _serde::__private::Some(__field) => __field,
1656 _serde::__private::None => {
1657 #[cfg(feature = "strict")]
1658 return _serde::__private::Err(
1659 <__A::Error as _serde::de::Error>::missing_field(
1660 "properties",
1661 ),
1662 );
1663 #[cfg(not(feature = "strict"))] Default::default()
1664 }
1665 };
1666 let m_material = match m_material {
1667 _serde::__private::Some(__field) => __field,
1668 _serde::__private::None => {
1669 #[cfg(feature = "strict")]
1670 return _serde::__private::Err(
1671 <__A::Error as _serde::de::Error>::missing_field("material"),
1672 );
1673 #[cfg(not(feature = "strict"))] Default::default()
1674 }
1675 };
1676 let m_damageMultiplier = match m_damageMultiplier {
1677 _serde::__private::Some(__field) => __field,
1678 _serde::__private::None => {
1679 #[cfg(feature = "strict")]
1680 return _serde::__private::Err(
1681 <__A::Error as _serde::de::Error>::missing_field(
1682 "damageMultiplier",
1683 ),
1684 );
1685 #[cfg(not(feature = "strict"))] Default::default()
1686 }
1687 };
1688 let m_storageIndex = match m_storageIndex {
1689 _serde::__private::Some(__field) => __field,
1690 _serde::__private::None => {
1691 #[cfg(feature = "strict")]
1692 return _serde::__private::Err(
1693 <__A::Error as _serde::de::Error>::missing_field(
1694 "storageIndex",
1695 ),
1696 );
1697 #[cfg(not(feature = "strict"))] Default::default()
1698 }
1699 };
1700 let m_contactPointCallbackDelay = match m_contactPointCallbackDelay {
1701 _serde::__private::Some(__field) => __field,
1702 _serde::__private::None => {
1703 #[cfg(feature = "strict")]
1704 return _serde::__private::Err(
1705 <__A::Error as _serde::de::Error>::missing_field(
1706 "contactPointCallbackDelay",
1707 ),
1708 );
1709 #[cfg(not(feature = "strict"))] Default::default()
1710 }
1711 };
1712 let m_autoRemoveLevel = match m_autoRemoveLevel {
1713 _serde::__private::Some(__field) => __field,
1714 _serde::__private::None => {
1715 #[cfg(feature = "strict")]
1716 return _serde::__private::Err(
1717 <__A::Error as _serde::de::Error>::missing_field(
1718 "autoRemoveLevel",
1719 ),
1720 );
1721 #[cfg(not(feature = "strict"))] Default::default()
1722 }
1723 };
1724 let m_numShapeKeysInContactPointProperties = match m_numShapeKeysInContactPointProperties {
1725 _serde::__private::Some(__field) => __field,
1726 _serde::__private::None => {
1727 #[cfg(feature = "strict")]
1728 return _serde::__private::Err(
1729 <__A::Error as _serde::de::Error>::missing_field(
1730 "numShapeKeysInContactPointProperties",
1731 ),
1732 );
1733 #[cfg(not(feature = "strict"))] Default::default()
1734 }
1735 };
1736 let m_responseModifierFlags = match m_responseModifierFlags {
1737 _serde::__private::Some(__field) => __field,
1738 _serde::__private::None => {
1739 #[cfg(feature = "strict")]
1740 return _serde::__private::Err(
1741 <__A::Error as _serde::de::Error>::missing_field(
1742 "responseModifierFlags",
1743 ),
1744 );
1745 #[cfg(not(feature = "strict"))] Default::default()
1746 }
1747 };
1748 let m_uid = match m_uid {
1749 _serde::__private::Some(__field) => __field,
1750 _serde::__private::None => {
1751 #[cfg(feature = "strict")]
1752 return _serde::__private::Err(
1753 <__A::Error as _serde::de::Error>::missing_field("uid"),
1754 );
1755 #[cfg(not(feature = "strict"))] Default::default()
1756 }
1757 };
1758 let m_spuCollisionCallback = match m_spuCollisionCallback {
1759 _serde::__private::Some(__field) => __field,
1760 _serde::__private::None => {
1761 #[cfg(feature = "strict")]
1762 return _serde::__private::Err(
1763 <__A::Error as _serde::de::Error>::missing_field(
1764 "spuCollisionCallback",
1765 ),
1766 );
1767 #[cfg(not(feature = "strict"))] Default::default()
1768 }
1769 };
1770 let m_motion = match m_motion {
1771 _serde::__private::Some(__field) => __field,
1772 _serde::__private::None => {
1773 #[cfg(feature = "strict")]
1774 return _serde::__private::Err(
1775 <__A::Error as _serde::de::Error>::missing_field("motion"),
1776 );
1777 #[cfg(not(feature = "strict"))] Default::default()
1778 }
1779 };
1780 let m_localFrame = match m_localFrame {
1781 _serde::__private::Some(__field) => __field,
1782 _serde::__private::None => {
1783 #[cfg(feature = "strict")]
1784 return _serde::__private::Err(
1785 <__A::Error as _serde::de::Error>::missing_field(
1786 "localFrame",
1787 ),
1788 );
1789 #[cfg(not(feature = "strict"))] Default::default()
1790 }
1791 };
1792 let m_npData = match m_npData {
1793 _serde::__private::Some(__field) => __field,
1794 _serde::__private::None => {
1795 #[cfg(feature = "strict")]
1796 return _serde::__private::Err(
1797 <__A::Error as _serde::de::Error>::missing_field("npData"),
1798 );
1799 #[cfg(not(feature = "strict"))] Default::default()
1800 }
1801 };
1802 let __ptr = None;
1803 let parent = hkBaseObject { __ptr };
1804 let parent = hkReferencedObject {
1805 __ptr,
1806 parent,
1807 ..Default::default()
1808 };
1809 let parent = hkpWorldObject {
1810 __ptr,
1811 parent,
1812 m_userData,
1813 m_collidable,
1814 m_multiThreadCheck,
1815 m_name,
1816 m_properties,
1817 ..Default::default()
1818 };
1819 let __ptr = __A::class_ptr(&mut __map);
1820 _serde::__private::Ok(hkpEntity {
1821 __ptr,
1822 parent,
1823 m_material,
1824 m_damageMultiplier,
1825 m_storageIndex,
1826 m_contactPointCallbackDelay,
1827 m_autoRemoveLevel,
1828 m_numShapeKeysInContactPointProperties,
1829 m_responseModifierFlags,
1830 m_uid,
1831 m_spuCollisionCallback,
1832 m_motion,
1833 m_localFrame,
1834 m_npData,
1835 ..Default::default()
1836 })
1837 }
1838 }
1839 const FIELDS: &[&str] = &[
1840 "material",
1841 "limitContactImpulseUtilAndFlag",
1842 "damageMultiplier",
1843 "breakableBody",
1844 "solverData",
1845 "storageIndex",
1846 "contactPointCallbackDelay",
1847 "constraintsMaster",
1848 "constraintsSlave",
1849 "constraintRuntime",
1850 "simulationIsland",
1851 "autoRemoveLevel",
1852 "numShapeKeysInContactPointProperties",
1853 "responseModifierFlags",
1854 "uid",
1855 "spuCollisionCallback",
1856 "motion",
1857 "contactListeners",
1858 "actions",
1859 "localFrame",
1860 "extendedListeners",
1861 "npData",
1862 ];
1863 _serde::Deserializer::deserialize_struct(
1864 deserializer,
1865 "hkpEntity",
1866 FIELDS,
1867 __hkpEntityVisitor {
1868 marker: _serde::__private::PhantomData::<hkpEntity>,
1869 lifetime: _serde::__private::PhantomData,
1870 },
1871 )
1872 }
1873 }
1874};