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 hkpStorageExtendedMeshShape {
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: hkpExtendedMeshShape,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "meshstorage"))]
35 #[cfg_attr(feature = "serde", serde(rename = "meshstorage"))]
36 pub m_meshstorage: Vec<Pointer>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "shapestorage"))]
42 #[cfg_attr(feature = "serde", serde(rename = "shapestorage"))]
43 pub m_shapestorage: Vec<Pointer>,
44}
45const _: () = {
46 use havok_serde as _serde;
47 impl _serde::HavokClass for hkpStorageExtendedMeshShape {
48 #[inline]
49 fn name(&self) -> &'static str {
50 "hkpStorageExtendedMeshShape"
51 }
52 #[inline]
53 fn signature(&self) -> _serde::__private::Signature {
54 _serde::__private::Signature::new(0xb469efbc)
55 }
56 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
57 fn deps_indexes(&self) -> Vec<usize> {
58 let mut v = Vec::new();
59 v.extend(self.parent.m_embeddedTrianglesSubpart.deps_indexes());
60 v.push(self.parent.m_materialClass.get());
61 v.extend(
62 self
63 .parent
64 .m_trianglesSubparts
65 .iter()
66 .flat_map(|class| class.deps_indexes())
67 .collect::<Vec<usize>>(),
68 );
69 v.extend(
70 self
71 .parent
72 .m_shapesSubparts
73 .iter()
74 .flat_map(|class| class.deps_indexes())
75 .collect::<Vec<usize>>(),
76 );
77 v.extend(self.m_meshstorage.iter().map(|ptr| ptr.get()));
78 v.extend(self.m_shapestorage.iter().map(|ptr| ptr.get()));
79 v
80 }
81 }
82 impl _serde::Serialize for hkpStorageExtendedMeshShape {
83 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
84 where
85 S: _serde::ser::Serializer,
86 {
87 let class_meta = self
88 .__ptr
89 .map(|name| (name, _serde::__private::Signature::new(0xb469efbc)));
90 let mut serializer = __serializer
91 .serialize_struct(
92 "hkpStorageExtendedMeshShape",
93 class_meta,
94 (272u64, 368u64),
95 )?;
96 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
97 serializer
98 .skip_field(
99 "memSizeAndFlags",
100 &self.parent.parent.parent.parent.m_memSizeAndFlags,
101 )?;
102 serializer
103 .skip_field(
104 "referenceCount",
105 &self.parent.parent.parent.parent.m_referenceCount,
106 )?;
107 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
108 serializer
109 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
110 serializer.skip_field("type", &self.parent.parent.parent.m_type)?;
111 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
112 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
113 serializer
114 .serialize_field(
115 "disableWelding",
116 &self.parent.parent.m_disableWelding,
117 )?;
118 serializer
119 .serialize_field(
120 "collectionType",
121 &self.parent.parent.m_collectionType,
122 )?;
123 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
124 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
125 serializer
126 .serialize_field(
127 "embeddedTrianglesSubpart",
128 &self.parent.m_embeddedTrianglesSubpart,
129 )?;
130 serializer
131 .serialize_field("aabbHalfExtents", &self.parent.m_aabbHalfExtents)?;
132 serializer.serialize_field("aabbCenter", &self.parent.m_aabbCenter)?;
133 serializer.skip_field("materialClass", &self.parent.m_materialClass)?;
134 serializer
135 .serialize_field(
136 "numBitsForSubpartIndex",
137 &self.parent.m_numBitsForSubpartIndex,
138 )?;
139 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
140 serializer
141 .serialize_array_field(
142 "trianglesSubparts",
143 &self.parent.m_trianglesSubparts,
144 TypeSize::Struct {
145 size_x86: 112u64,
146 size_x86_64: 160u64,
147 },
148 )?;
149 serializer
150 .serialize_array_field(
151 "shapesSubparts",
152 &self.parent.m_shapesSubparts,
153 TypeSize::Struct {
154 size_x86: 64u64,
155 size_x86_64: 96u64,
156 },
157 )?;
158 serializer
159 .serialize_array_field(
160 "weldingInfo",
161 &self.parent.m_weldingInfo,
162 TypeSize::NonPtr,
163 )?;
164 serializer.serialize_field("weldingType", &self.parent.m_weldingType)?;
165 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
166 serializer
167 .serialize_field(
168 "defaultCollisionFilterInfo",
169 &self.parent.m_defaultCollisionFilterInfo,
170 )?;
171 serializer
172 .serialize_field(
173 "cachedNumChildShapes",
174 &self.parent.m_cachedNumChildShapes,
175 )?;
176 serializer.serialize_field("triangleRadius", &self.parent.m_triangleRadius)?;
177 serializer.skip_field("padding", &self.parent.m_padding)?;
178 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 12usize].as_slice())?;
179 serializer
180 .serialize_array_field(
181 "meshstorage",
182 &self.m_meshstorage,
183 TypeSize::NonPtr,
184 )?;
185 serializer
186 .serialize_array_field(
187 "shapestorage",
188 &self.m_shapestorage,
189 TypeSize::NonPtr,
190 )?;
191 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
192 serializer.end()
193 }
194 }
195};
196#[doc(hidden)]
197#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
198const _: () = {
199 use havok_serde as _serde;
200 #[automatically_derived]
201 impl<'de> _serde::Deserialize<'de> for hkpStorageExtendedMeshShape {
202 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
203 where
204 __D: _serde::Deserializer<'de>,
205 {
206 #[allow(non_camel_case_types)]
207 enum __Field {
208 m_userData,
209 m_disableWelding,
210 m_collectionType,
211 m_embeddedTrianglesSubpart,
212 m_aabbHalfExtents,
213 m_aabbCenter,
214 m_numBitsForSubpartIndex,
215 m_trianglesSubparts,
216 m_shapesSubparts,
217 m_weldingInfo,
218 m_weldingType,
219 m_defaultCollisionFilterInfo,
220 m_cachedNumChildShapes,
221 m_triangleRadius,
222 m_meshstorage,
223 m_shapestorage,
224 __ignore,
225 }
226 struct __FieldVisitor;
227 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
228 type Value = __Field;
229 fn expecting(
230 &self,
231 __formatter: &mut core::fmt::Formatter,
232 ) -> core::fmt::Result {
233 core::fmt::Formatter::write_str(__formatter, "field identifier")
234 }
235 #[allow(clippy::match_single_binding)]
237 #[allow(clippy::reversed_empty_ranges)]
238 #[allow(clippy::single_match)]
239 fn visit_key<__E>(
240 self,
241 __value: &str,
242 ) -> core::result::Result<Self::Value, __E>
243 where
244 __E: _serde::de::Error,
245 {
246 match __value {
247 "userData" => Ok(__Field::m_userData),
248 "disableWelding" => Ok(__Field::m_disableWelding),
249 "collectionType" => Ok(__Field::m_collectionType),
250 "embeddedTrianglesSubpart" => {
251 Ok(__Field::m_embeddedTrianglesSubpart)
252 }
253 "aabbHalfExtents" => Ok(__Field::m_aabbHalfExtents),
254 "aabbCenter" => Ok(__Field::m_aabbCenter),
255 "numBitsForSubpartIndex" => Ok(__Field::m_numBitsForSubpartIndex),
256 "trianglesSubparts" => Ok(__Field::m_trianglesSubparts),
257 "shapesSubparts" => Ok(__Field::m_shapesSubparts),
258 "weldingInfo" => Ok(__Field::m_weldingInfo),
259 "weldingType" => Ok(__Field::m_weldingType),
260 "defaultCollisionFilterInfo" => {
261 Ok(__Field::m_defaultCollisionFilterInfo)
262 }
263 "cachedNumChildShapes" => Ok(__Field::m_cachedNumChildShapes),
264 "triangleRadius" => Ok(__Field::m_triangleRadius),
265 "meshstorage" => Ok(__Field::m_meshstorage),
266 "shapestorage" => Ok(__Field::m_shapestorage),
267 _ => Ok(__Field::__ignore),
268 }
269 }
270 }
271 impl<'de> _serde::Deserialize<'de> for __Field {
272 #[inline]
273 fn deserialize<__D>(
274 __deserializer: __D,
275 ) -> core::result::Result<Self, __D::Error>
276 where
277 __D: _serde::Deserializer<'de>,
278 {
279 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
280 }
281 }
282 struct __hkpStorageExtendedMeshShapeVisitor<'de> {
283 marker: _serde::__private::PhantomData<hkpStorageExtendedMeshShape>,
284 lifetime: _serde::__private::PhantomData<&'de ()>,
285 }
286 #[allow(clippy::match_single_binding)]
287 #[allow(clippy::reversed_empty_ranges)]
288 #[allow(clippy::single_match)]
289 impl<'de> _serde::de::Visitor<'de>
290 for __hkpStorageExtendedMeshShapeVisitor<'de> {
291 type Value = hkpStorageExtendedMeshShape;
292 fn expecting(
293 &self,
294 __formatter: &mut core::fmt::Formatter,
295 ) -> core::fmt::Result {
296 core::fmt::Formatter::write_str(
297 __formatter,
298 "struct hkpStorageExtendedMeshShape",
299 )
300 }
301 fn visit_struct_for_bytes<__A>(
302 self,
303 mut __map: __A,
304 ) -> _serde::__private::Result<Self::Value, __A::Error>
305 where
306 __A: _serde::de::MapAccess<'de>,
307 {
308 let __ptr = __A::class_ptr(&mut __map);
309 let parent = __A::parent_value(&mut __map)?;
310 let mut m_meshstorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
311 let mut m_shapestorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
312 for i in 0..2usize {
313 match i {
314 0usize => {
315 if _serde::__private::Option::is_some(&m_meshstorage) {
316 return _serde::__private::Err(
317 <__A::Error as _serde::de::Error>::duplicate_field(
318 "meshstorage",
319 ),
320 );
321 }
322 m_meshstorage = _serde::__private::Some(
323 match __A::next_value::<Vec<Pointer>>(&mut __map) {
324 _serde::__private::Ok(__val) => __val,
325 _serde::__private::Err(__err) => {
326 return _serde::__private::Err(__err);
327 }
328 },
329 );
330 }
331 1usize => {
332 if _serde::__private::Option::is_some(&m_shapestorage) {
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::duplicate_field(
335 "shapestorage",
336 ),
337 );
338 }
339 m_shapestorage = _serde::__private::Some(
340 match __A::next_value::<Vec<Pointer>>(&mut __map) {
341 _serde::__private::Ok(__val) => __val,
342 _serde::__private::Err(__err) => {
343 return _serde::__private::Err(__err);
344 }
345 },
346 );
347 }
348 _ => {}
349 }
350 }
351 __A::pad(&mut __map, 8usize, 0usize)?;
352 let m_meshstorage = match m_meshstorage {
353 _serde::__private::Some(__field) => __field,
354 _serde::__private::None => {
355 return _serde::__private::Err(
356 <__A::Error as _serde::de::Error>::missing_field(
357 "meshstorage",
358 ),
359 );
360 }
361 };
362 let m_shapestorage = match m_shapestorage {
363 _serde::__private::Some(__field) => __field,
364 _serde::__private::None => {
365 return _serde::__private::Err(
366 <__A::Error as _serde::de::Error>::missing_field(
367 "shapestorage",
368 ),
369 );
370 }
371 };
372 _serde::__private::Ok(hkpStorageExtendedMeshShape {
373 __ptr,
374 parent,
375 m_meshstorage,
376 m_shapestorage,
377 })
378 }
379 #[allow(clippy::manual_unwrap_or_default)]
380 fn visit_struct<__A>(
381 self,
382 mut __map: __A,
383 ) -> _serde::__private::Result<Self::Value, __A::Error>
384 where
385 __A: _serde::de::MapAccess<'de>,
386 {
387 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
388 let mut m_disableWelding: _serde::__private::Option<bool> = _serde::__private::None;
389 let mut m_collectionType: _serde::__private::Option<
390 CollectionType,
391 > = _serde::__private::None;
392 let mut m_embeddedTrianglesSubpart: _serde::__private::Option<
393 hkpExtendedMeshShapeTrianglesSubpart,
394 > = _serde::__private::None;
395 let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
396 let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
397 let mut m_numBitsForSubpartIndex: _serde::__private::Option<i32> = _serde::__private::None;
398 let mut m_trianglesSubparts: _serde::__private::Option<
399 Vec<hkpExtendedMeshShapeTrianglesSubpart>,
400 > = _serde::__private::None;
401 let mut m_shapesSubparts: _serde::__private::Option<
402 Vec<hkpExtendedMeshShapeShapesSubpart>,
403 > = _serde::__private::None;
404 let mut m_weldingInfo: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
405 let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
406 let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
407 u32,
408 > = _serde::__private::None;
409 let mut m_cachedNumChildShapes: _serde::__private::Option<i32> = _serde::__private::None;
410 let mut m_triangleRadius: _serde::__private::Option<f32> = _serde::__private::None;
411 let mut m_meshstorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
412 let mut m_shapestorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
413 while let _serde::__private::Some(__key) = {
414 __A::next_key::<__Field>(&mut __map)?
415 } {
416 match __key {
417 __Field::m_userData => {
418 #[cfg(
419 any(feature = "strict", feature = "ignore_duplicates")
420 )]
421 if _serde::__private::Option::is_some(&m_userData) {
422 #[cfg(feature = "ignore_duplicates")]
423 {
424 __A::skip_value(&mut __map)?;
425 continue;
426 }
427 #[cfg(feature = "strict")]
428 return _serde::__private::Err(
429 <__A::Error as _serde::de::Error>::duplicate_field(
430 "userData",
431 ),
432 );
433 }
434 m_userData = _serde::__private::Some(
435 match __A::next_value::<Ulong>(&mut __map) {
436 _serde::__private::Ok(__val) => __val,
437 _serde::__private::Err(__err) => {
438 return _serde::__private::Err(__err);
439 }
440 },
441 );
442 }
443 __Field::m_disableWelding => {
444 #[cfg(
445 any(feature = "strict", feature = "ignore_duplicates")
446 )]
447 if _serde::__private::Option::is_some(&m_disableWelding) {
448 #[cfg(feature = "ignore_duplicates")]
449 {
450 __A::skip_value(&mut __map)?;
451 continue;
452 }
453 #[cfg(feature = "strict")]
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::duplicate_field(
456 "disableWelding",
457 ),
458 );
459 }
460 m_disableWelding = _serde::__private::Some(
461 match __A::next_value::<bool>(&mut __map) {
462 _serde::__private::Ok(__val) => __val,
463 _serde::__private::Err(__err) => {
464 return _serde::__private::Err(__err);
465 }
466 },
467 );
468 }
469 __Field::m_collectionType => {
470 #[cfg(
471 any(feature = "strict", feature = "ignore_duplicates")
472 )]
473 if _serde::__private::Option::is_some(&m_collectionType) {
474 #[cfg(feature = "ignore_duplicates")]
475 {
476 __A::skip_value(&mut __map)?;
477 continue;
478 }
479 #[cfg(feature = "strict")]
480 return _serde::__private::Err(
481 <__A::Error as _serde::de::Error>::duplicate_field(
482 "collectionType",
483 ),
484 );
485 }
486 m_collectionType = _serde::__private::Some(
487 match __A::next_value::<CollectionType>(&mut __map) {
488 _serde::__private::Ok(__val) => __val,
489 _serde::__private::Err(__err) => {
490 return _serde::__private::Err(__err);
491 }
492 },
493 );
494 }
495 __Field::m_embeddedTrianglesSubpart => {
496 #[cfg(
497 any(feature = "strict", feature = "ignore_duplicates")
498 )]
499 if _serde::__private::Option::is_some(
500 &m_embeddedTrianglesSubpart,
501 ) {
502 #[cfg(feature = "ignore_duplicates")]
503 {
504 __A::skip_value(&mut __map)?;
505 continue;
506 }
507 #[cfg(feature = "strict")]
508 return _serde::__private::Err(
509 <__A::Error as _serde::de::Error>::duplicate_field(
510 "embeddedTrianglesSubpart",
511 ),
512 );
513 }
514 m_embeddedTrianglesSubpart = _serde::__private::Some(
515 match __A::next_value::<
516 hkpExtendedMeshShapeTrianglesSubpart,
517 >(&mut __map) {
518 _serde::__private::Ok(__val) => __val,
519 _serde::__private::Err(__err) => {
520 return _serde::__private::Err(__err);
521 }
522 },
523 );
524 }
525 __Field::m_aabbHalfExtents => {
526 #[cfg(
527 any(feature = "strict", feature = "ignore_duplicates")
528 )]
529 if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
530 #[cfg(feature = "ignore_duplicates")]
531 {
532 __A::skip_value(&mut __map)?;
533 continue;
534 }
535 #[cfg(feature = "strict")]
536 return _serde::__private::Err(
537 <__A::Error as _serde::de::Error>::duplicate_field(
538 "aabbHalfExtents",
539 ),
540 );
541 }
542 m_aabbHalfExtents = _serde::__private::Some(
543 match __A::next_value::<Vector4>(&mut __map) {
544 _serde::__private::Ok(__val) => __val,
545 _serde::__private::Err(__err) => {
546 return _serde::__private::Err(__err);
547 }
548 },
549 );
550 }
551 __Field::m_aabbCenter => {
552 #[cfg(
553 any(feature = "strict", feature = "ignore_duplicates")
554 )]
555 if _serde::__private::Option::is_some(&m_aabbCenter) {
556 #[cfg(feature = "ignore_duplicates")]
557 {
558 __A::skip_value(&mut __map)?;
559 continue;
560 }
561 #[cfg(feature = "strict")]
562 return _serde::__private::Err(
563 <__A::Error as _serde::de::Error>::duplicate_field(
564 "aabbCenter",
565 ),
566 );
567 }
568 m_aabbCenter = _serde::__private::Some(
569 match __A::next_value::<Vector4>(&mut __map) {
570 _serde::__private::Ok(__val) => __val,
571 _serde::__private::Err(__err) => {
572 return _serde::__private::Err(__err);
573 }
574 },
575 );
576 }
577 __Field::m_numBitsForSubpartIndex => {
578 #[cfg(
579 any(feature = "strict", feature = "ignore_duplicates")
580 )]
581 if _serde::__private::Option::is_some(
582 &m_numBitsForSubpartIndex,
583 ) {
584 #[cfg(feature = "ignore_duplicates")]
585 {
586 __A::skip_value(&mut __map)?;
587 continue;
588 }
589 #[cfg(feature = "strict")]
590 return _serde::__private::Err(
591 <__A::Error as _serde::de::Error>::duplicate_field(
592 "numBitsForSubpartIndex",
593 ),
594 );
595 }
596 m_numBitsForSubpartIndex = _serde::__private::Some(
597 match __A::next_value::<i32>(&mut __map) {
598 _serde::__private::Ok(__val) => __val,
599 _serde::__private::Err(__err) => {
600 return _serde::__private::Err(__err);
601 }
602 },
603 );
604 }
605 __Field::m_trianglesSubparts => {
606 #[cfg(
607 any(feature = "strict", feature = "ignore_duplicates")
608 )]
609 if _serde::__private::Option::is_some(
610 &m_trianglesSubparts,
611 ) {
612 #[cfg(feature = "ignore_duplicates")]
613 {
614 __A::skip_value(&mut __map)?;
615 continue;
616 }
617 #[cfg(feature = "strict")]
618 return _serde::__private::Err(
619 <__A::Error as _serde::de::Error>::duplicate_field(
620 "trianglesSubparts",
621 ),
622 );
623 }
624 m_trianglesSubparts = _serde::__private::Some(
625 match __A::next_value::<
626 Vec<hkpExtendedMeshShapeTrianglesSubpart>,
627 >(&mut __map) {
628 _serde::__private::Ok(__val) => __val,
629 _serde::__private::Err(__err) => {
630 return _serde::__private::Err(__err);
631 }
632 },
633 );
634 }
635 __Field::m_shapesSubparts => {
636 #[cfg(
637 any(feature = "strict", feature = "ignore_duplicates")
638 )]
639 if _serde::__private::Option::is_some(&m_shapesSubparts) {
640 #[cfg(feature = "ignore_duplicates")]
641 {
642 __A::skip_value(&mut __map)?;
643 continue;
644 }
645 #[cfg(feature = "strict")]
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::duplicate_field(
648 "shapesSubparts",
649 ),
650 );
651 }
652 m_shapesSubparts = _serde::__private::Some(
653 match __A::next_value::<
654 Vec<hkpExtendedMeshShapeShapesSubpart>,
655 >(&mut __map) {
656 _serde::__private::Ok(__val) => __val,
657 _serde::__private::Err(__err) => {
658 return _serde::__private::Err(__err);
659 }
660 },
661 );
662 }
663 __Field::m_weldingInfo => {
664 #[cfg(
665 any(feature = "strict", feature = "ignore_duplicates")
666 )]
667 if _serde::__private::Option::is_some(&m_weldingInfo) {
668 #[cfg(feature = "ignore_duplicates")]
669 {
670 __A::skip_value(&mut __map)?;
671 continue;
672 }
673 #[cfg(feature = "strict")]
674 return _serde::__private::Err(
675 <__A::Error as _serde::de::Error>::duplicate_field(
676 "weldingInfo",
677 ),
678 );
679 }
680 m_weldingInfo = _serde::__private::Some(
681 match __A::next_value::<Vec<u16>>(&mut __map) {
682 _serde::__private::Ok(__val) => __val,
683 _serde::__private::Err(__err) => {
684 return _serde::__private::Err(__err);
685 }
686 },
687 );
688 }
689 __Field::m_weldingType => {
690 #[cfg(
691 any(feature = "strict", feature = "ignore_duplicates")
692 )]
693 if _serde::__private::Option::is_some(&m_weldingType) {
694 #[cfg(feature = "ignore_duplicates")]
695 {
696 __A::skip_value(&mut __map)?;
697 continue;
698 }
699 #[cfg(feature = "strict")]
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::duplicate_field(
702 "weldingType",
703 ),
704 );
705 }
706 m_weldingType = _serde::__private::Some(
707 match __A::next_value::<WeldingType>(&mut __map) {
708 _serde::__private::Ok(__val) => __val,
709 _serde::__private::Err(__err) => {
710 return _serde::__private::Err(__err);
711 }
712 },
713 );
714 }
715 __Field::m_defaultCollisionFilterInfo => {
716 #[cfg(
717 any(feature = "strict", feature = "ignore_duplicates")
718 )]
719 if _serde::__private::Option::is_some(
720 &m_defaultCollisionFilterInfo,
721 ) {
722 #[cfg(feature = "ignore_duplicates")]
723 {
724 __A::skip_value(&mut __map)?;
725 continue;
726 }
727 #[cfg(feature = "strict")]
728 return _serde::__private::Err(
729 <__A::Error as _serde::de::Error>::duplicate_field(
730 "defaultCollisionFilterInfo",
731 ),
732 );
733 }
734 m_defaultCollisionFilterInfo = _serde::__private::Some(
735 match __A::next_value::<u32>(&mut __map) {
736 _serde::__private::Ok(__val) => __val,
737 _serde::__private::Err(__err) => {
738 return _serde::__private::Err(__err);
739 }
740 },
741 );
742 }
743 __Field::m_cachedNumChildShapes => {
744 #[cfg(
745 any(feature = "strict", feature = "ignore_duplicates")
746 )]
747 if _serde::__private::Option::is_some(
748 &m_cachedNumChildShapes,
749 ) {
750 #[cfg(feature = "ignore_duplicates")]
751 {
752 __A::skip_value(&mut __map)?;
753 continue;
754 }
755 #[cfg(feature = "strict")]
756 return _serde::__private::Err(
757 <__A::Error as _serde::de::Error>::duplicate_field(
758 "cachedNumChildShapes",
759 ),
760 );
761 }
762 m_cachedNumChildShapes = _serde::__private::Some(
763 match __A::next_value::<i32>(&mut __map) {
764 _serde::__private::Ok(__val) => __val,
765 _serde::__private::Err(__err) => {
766 return _serde::__private::Err(__err);
767 }
768 },
769 );
770 }
771 __Field::m_triangleRadius => {
772 #[cfg(
773 any(feature = "strict", feature = "ignore_duplicates")
774 )]
775 if _serde::__private::Option::is_some(&m_triangleRadius) {
776 #[cfg(feature = "ignore_duplicates")]
777 {
778 __A::skip_value(&mut __map)?;
779 continue;
780 }
781 #[cfg(feature = "strict")]
782 return _serde::__private::Err(
783 <__A::Error as _serde::de::Error>::duplicate_field(
784 "triangleRadius",
785 ),
786 );
787 }
788 m_triangleRadius = _serde::__private::Some(
789 match __A::next_value::<f32>(&mut __map) {
790 _serde::__private::Ok(__val) => __val,
791 _serde::__private::Err(__err) => {
792 return _serde::__private::Err(__err);
793 }
794 },
795 );
796 }
797 __Field::m_meshstorage => {
798 #[cfg(
799 any(feature = "strict", feature = "ignore_duplicates")
800 )]
801 if _serde::__private::Option::is_some(&m_meshstorage) {
802 #[cfg(feature = "ignore_duplicates")]
803 {
804 __A::skip_value(&mut __map)?;
805 continue;
806 }
807 #[cfg(feature = "strict")]
808 return _serde::__private::Err(
809 <__A::Error as _serde::de::Error>::duplicate_field(
810 "meshstorage",
811 ),
812 );
813 }
814 m_meshstorage = _serde::__private::Some(
815 match __A::next_value::<Vec<Pointer>>(&mut __map) {
816 _serde::__private::Ok(__val) => __val,
817 _serde::__private::Err(__err) => {
818 return _serde::__private::Err(__err);
819 }
820 },
821 );
822 }
823 __Field::m_shapestorage => {
824 #[cfg(
825 any(feature = "strict", feature = "ignore_duplicates")
826 )]
827 if _serde::__private::Option::is_some(&m_shapestorage) {
828 #[cfg(feature = "ignore_duplicates")]
829 {
830 __A::skip_value(&mut __map)?;
831 continue;
832 }
833 #[cfg(feature = "strict")]
834 return _serde::__private::Err(
835 <__A::Error as _serde::de::Error>::duplicate_field(
836 "shapestorage",
837 ),
838 );
839 }
840 m_shapestorage = _serde::__private::Some(
841 match __A::next_value::<Vec<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 _ => __A::skip_value(&mut __map)?,
850 }
851 }
852 let m_userData = match m_userData {
853 _serde::__private::Some(__field) => __field,
854 _serde::__private::None => {
855 #[cfg(feature = "strict")]
856 return _serde::__private::Err(
857 <__A::Error as _serde::de::Error>::missing_field("userData"),
858 );
859 #[cfg(not(feature = "strict"))] Default::default()
860 }
861 };
862 let m_disableWelding = match m_disableWelding {
863 _serde::__private::Some(__field) => __field,
864 _serde::__private::None => {
865 #[cfg(feature = "strict")]
866 return _serde::__private::Err(
867 <__A::Error as _serde::de::Error>::missing_field(
868 "disableWelding",
869 ),
870 );
871 #[cfg(not(feature = "strict"))] Default::default()
872 }
873 };
874 let m_collectionType = match m_collectionType {
875 _serde::__private::Some(__field) => __field,
876 _serde::__private::None => {
877 #[cfg(feature = "strict")]
878 return _serde::__private::Err(
879 <__A::Error as _serde::de::Error>::missing_field(
880 "collectionType",
881 ),
882 );
883 #[cfg(not(feature = "strict"))] Default::default()
884 }
885 };
886 let m_embeddedTrianglesSubpart = match m_embeddedTrianglesSubpart {
887 _serde::__private::Some(__field) => __field,
888 _serde::__private::None => {
889 #[cfg(feature = "strict")]
890 return _serde::__private::Err(
891 <__A::Error as _serde::de::Error>::missing_field(
892 "embeddedTrianglesSubpart",
893 ),
894 );
895 #[cfg(not(feature = "strict"))] Default::default()
896 }
897 };
898 let m_aabbHalfExtents = match m_aabbHalfExtents {
899 _serde::__private::Some(__field) => __field,
900 _serde::__private::None => {
901 #[cfg(feature = "strict")]
902 return _serde::__private::Err(
903 <__A::Error as _serde::de::Error>::missing_field(
904 "aabbHalfExtents",
905 ),
906 );
907 #[cfg(not(feature = "strict"))] Default::default()
908 }
909 };
910 let m_aabbCenter = match m_aabbCenter {
911 _serde::__private::Some(__field) => __field,
912 _serde::__private::None => {
913 #[cfg(feature = "strict")]
914 return _serde::__private::Err(
915 <__A::Error as _serde::de::Error>::missing_field(
916 "aabbCenter",
917 ),
918 );
919 #[cfg(not(feature = "strict"))] Default::default()
920 }
921 };
922 let m_numBitsForSubpartIndex = match m_numBitsForSubpartIndex {
923 _serde::__private::Some(__field) => __field,
924 _serde::__private::None => {
925 #[cfg(feature = "strict")]
926 return _serde::__private::Err(
927 <__A::Error as _serde::de::Error>::missing_field(
928 "numBitsForSubpartIndex",
929 ),
930 );
931 #[cfg(not(feature = "strict"))] Default::default()
932 }
933 };
934 let m_trianglesSubparts = match m_trianglesSubparts {
935 _serde::__private::Some(__field) => __field,
936 _serde::__private::None => {
937 #[cfg(feature = "strict")]
938 return _serde::__private::Err(
939 <__A::Error as _serde::de::Error>::missing_field(
940 "trianglesSubparts",
941 ),
942 );
943 #[cfg(not(feature = "strict"))] Default::default()
944 }
945 };
946 let m_shapesSubparts = match m_shapesSubparts {
947 _serde::__private::Some(__field) => __field,
948 _serde::__private::None => {
949 #[cfg(feature = "strict")]
950 return _serde::__private::Err(
951 <__A::Error as _serde::de::Error>::missing_field(
952 "shapesSubparts",
953 ),
954 );
955 #[cfg(not(feature = "strict"))] Default::default()
956 }
957 };
958 let m_weldingInfo = match m_weldingInfo {
959 _serde::__private::Some(__field) => __field,
960 _serde::__private::None => {
961 #[cfg(feature = "strict")]
962 return _serde::__private::Err(
963 <__A::Error as _serde::de::Error>::missing_field(
964 "weldingInfo",
965 ),
966 );
967 #[cfg(not(feature = "strict"))] Default::default()
968 }
969 };
970 let m_weldingType = match m_weldingType {
971 _serde::__private::Some(__field) => __field,
972 _serde::__private::None => {
973 #[cfg(feature = "strict")]
974 return _serde::__private::Err(
975 <__A::Error as _serde::de::Error>::missing_field(
976 "weldingType",
977 ),
978 );
979 #[cfg(not(feature = "strict"))] Default::default()
980 }
981 };
982 let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
983 _serde::__private::Some(__field) => __field,
984 _serde::__private::None => {
985 #[cfg(feature = "strict")]
986 return _serde::__private::Err(
987 <__A::Error as _serde::de::Error>::missing_field(
988 "defaultCollisionFilterInfo",
989 ),
990 );
991 #[cfg(not(feature = "strict"))] Default::default()
992 }
993 };
994 let m_cachedNumChildShapes = match m_cachedNumChildShapes {
995 _serde::__private::Some(__field) => __field,
996 _serde::__private::None => {
997 #[cfg(feature = "strict")]
998 return _serde::__private::Err(
999 <__A::Error as _serde::de::Error>::missing_field(
1000 "cachedNumChildShapes",
1001 ),
1002 );
1003 #[cfg(not(feature = "strict"))] Default::default()
1004 }
1005 };
1006 let m_triangleRadius = match m_triangleRadius {
1007 _serde::__private::Some(__field) => __field,
1008 _serde::__private::None => {
1009 #[cfg(feature = "strict")]
1010 return _serde::__private::Err(
1011 <__A::Error as _serde::de::Error>::missing_field(
1012 "triangleRadius",
1013 ),
1014 );
1015 #[cfg(not(feature = "strict"))] Default::default()
1016 }
1017 };
1018 let m_meshstorage = match m_meshstorage {
1019 _serde::__private::Some(__field) => __field,
1020 _serde::__private::None => {
1021 #[cfg(feature = "strict")]
1022 return _serde::__private::Err(
1023 <__A::Error as _serde::de::Error>::missing_field(
1024 "meshstorage",
1025 ),
1026 );
1027 #[cfg(not(feature = "strict"))] Default::default()
1028 }
1029 };
1030 let m_shapestorage = match m_shapestorage {
1031 _serde::__private::Some(__field) => __field,
1032 _serde::__private::None => {
1033 #[cfg(feature = "strict")]
1034 return _serde::__private::Err(
1035 <__A::Error as _serde::de::Error>::missing_field(
1036 "shapestorage",
1037 ),
1038 );
1039 #[cfg(not(feature = "strict"))] Default::default()
1040 }
1041 };
1042 let __ptr = None;
1043 let parent = hkBaseObject { __ptr };
1044 let parent = hkReferencedObject {
1045 __ptr,
1046 parent,
1047 ..Default::default()
1048 };
1049 let parent = hkpShape {
1050 __ptr,
1051 parent,
1052 m_userData,
1053 ..Default::default()
1054 };
1055 let parent = hkpShapeCollection {
1056 __ptr,
1057 parent,
1058 m_disableWelding,
1059 m_collectionType,
1060 };
1061 let parent = hkpExtendedMeshShape {
1062 __ptr,
1063 parent,
1064 m_embeddedTrianglesSubpart,
1065 m_aabbHalfExtents,
1066 m_aabbCenter,
1067 m_numBitsForSubpartIndex,
1068 m_trianglesSubparts,
1069 m_shapesSubparts,
1070 m_weldingInfo,
1071 m_weldingType,
1072 m_defaultCollisionFilterInfo,
1073 m_cachedNumChildShapes,
1074 m_triangleRadius,
1075 ..Default::default()
1076 };
1077 let __ptr = __A::class_ptr(&mut __map);
1078 _serde::__private::Ok(hkpStorageExtendedMeshShape {
1079 __ptr,
1080 parent,
1081 m_meshstorage,
1082 m_shapestorage,
1083 })
1084 }
1085 }
1086 const FIELDS: &[&str] = &["meshstorage", "shapestorage"];
1087 _serde::Deserializer::deserialize_struct(
1088 deserializer,
1089 "hkpStorageExtendedMeshShape",
1090 FIELDS,
1091 __hkpStorageExtendedMeshShapeVisitor {
1092 marker: _serde::__private::PhantomData::<
1093 hkpStorageExtendedMeshShape,
1094 >,
1095 lifetime: _serde::__private::PhantomData,
1096 },
1097 )
1098 }
1099 }
1100};