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 hkpListShape {
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: hkpShapeCollection,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "childInfo"))]
35 #[cfg_attr(feature = "serde", serde(rename = "childInfo"))]
36 pub m_childInfo: Vec<hkpListShapeChildInfo>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
42 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
43 pub m_flags: u16,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "numDisabledChildren"))]
49 #[cfg_attr(feature = "serde", serde(rename = "numDisabledChildren"))]
50 pub m_numDisabledChildren: u16,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "aabbHalfExtents"))]
56 #[cfg_attr(feature = "serde", serde(rename = "aabbHalfExtents"))]
57 pub m_aabbHalfExtents: Vector4,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "aabbCenter"))]
63 #[cfg_attr(feature = "serde", serde(rename = "aabbCenter"))]
64 pub m_aabbCenter: Vector4,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "enabledChildren"))]
70 #[cfg_attr(feature = "serde", serde(rename = "enabledChildren"))]
71 pub m_enabledChildren: [u32; 8usize],
72}
73const _: () = {
74 use havok_serde as _serde;
75 impl _serde::HavokClass for hkpListShape {
76 #[inline]
77 fn name(&self) -> &'static str {
78 "hkpListShape"
79 }
80 #[inline]
81 fn signature(&self) -> _serde::__private::Signature {
82 _serde::__private::Signature::new(0xa1937cbd)
83 }
84 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
85 fn deps_indexes(&self) -> Vec<usize> {
86 let mut v = Vec::new();
87 v.extend(
88 self
89 .m_childInfo
90 .iter()
91 .flat_map(|class| class.deps_indexes())
92 .collect::<Vec<usize>>(),
93 );
94 v
95 }
96 }
97 impl _serde::Serialize for hkpListShape {
98 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
99 where
100 S: _serde::ser::Serializer,
101 {
102 let class_meta = self
103 .__ptr
104 .map(|name| (name, _serde::__private::Signature::new(0xa1937cbd)));
105 let mut serializer = __serializer
106 .serialize_struct("hkpListShape", class_meta, (112u64, 144u64))?;
107 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
108 serializer
109 .skip_field(
110 "memSizeAndFlags",
111 &self.parent.parent.parent.m_memSizeAndFlags,
112 )?;
113 serializer
114 .skip_field(
115 "referenceCount",
116 &self.parent.parent.parent.m_referenceCount,
117 )?;
118 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
119 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
120 serializer.skip_field("type", &self.parent.parent.m_type)?;
121 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
122 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
123 serializer.serialize_field("disableWelding", &self.parent.m_disableWelding)?;
124 serializer.serialize_field("collectionType", &self.parent.m_collectionType)?;
125 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
126 serializer
127 .serialize_array_field(
128 "childInfo",
129 &self.m_childInfo,
130 TypeSize::Struct {
131 size_x86: 16u64,
132 size_x86_64: 32u64,
133 },
134 )?;
135 serializer.serialize_field("flags", &self.m_flags)?;
136 serializer
137 .serialize_field("numDisabledChildren", &self.m_numDisabledChildren)?;
138 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 12usize].as_slice())?;
139 serializer.serialize_field("aabbHalfExtents", &self.m_aabbHalfExtents)?;
140 serializer.serialize_field("aabbCenter", &self.m_aabbCenter)?;
141 serializer
142 .serialize_fixed_array_field(
143 "enabledChildren",
144 self.m_enabledChildren.as_slice(),
145 TypeSize::NonPtr,
146 )?;
147 serializer.end()
148 }
149 }
150};
151#[doc(hidden)]
152#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
153const _: () = {
154 use havok_serde as _serde;
155 #[automatically_derived]
156 impl<'de> _serde::Deserialize<'de> for hkpListShape {
157 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
158 where
159 __D: _serde::Deserializer<'de>,
160 {
161 #[allow(non_camel_case_types)]
162 enum __Field {
163 m_userData,
164 m_disableWelding,
165 m_collectionType,
166 m_childInfo,
167 m_flags,
168 m_numDisabledChildren,
169 m_aabbHalfExtents,
170 m_aabbCenter,
171 m_enabledChildren,
172 __ignore,
173 }
174 struct __FieldVisitor;
175 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
176 type Value = __Field;
177 fn expecting(
178 &self,
179 __formatter: &mut core::fmt::Formatter,
180 ) -> core::fmt::Result {
181 core::fmt::Formatter::write_str(__formatter, "field identifier")
182 }
183 #[allow(clippy::match_single_binding)]
185 #[allow(clippy::reversed_empty_ranges)]
186 #[allow(clippy::single_match)]
187 fn visit_key<__E>(
188 self,
189 __value: &str,
190 ) -> core::result::Result<Self::Value, __E>
191 where
192 __E: _serde::de::Error,
193 {
194 match __value {
195 "userData" => Ok(__Field::m_userData),
196 "disableWelding" => Ok(__Field::m_disableWelding),
197 "collectionType" => Ok(__Field::m_collectionType),
198 "childInfo" => Ok(__Field::m_childInfo),
199 "flags" => Ok(__Field::m_flags),
200 "numDisabledChildren" => Ok(__Field::m_numDisabledChildren),
201 "aabbHalfExtents" => Ok(__Field::m_aabbHalfExtents),
202 "aabbCenter" => Ok(__Field::m_aabbCenter),
203 "enabledChildren" => Ok(__Field::m_enabledChildren),
204 _ => Ok(__Field::__ignore),
205 }
206 }
207 }
208 impl<'de> _serde::Deserialize<'de> for __Field {
209 #[inline]
210 fn deserialize<__D>(
211 __deserializer: __D,
212 ) -> core::result::Result<Self, __D::Error>
213 where
214 __D: _serde::Deserializer<'de>,
215 {
216 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
217 }
218 }
219 struct __hkpListShapeVisitor<'de> {
220 marker: _serde::__private::PhantomData<hkpListShape>,
221 lifetime: _serde::__private::PhantomData<&'de ()>,
222 }
223 #[allow(clippy::match_single_binding)]
224 #[allow(clippy::reversed_empty_ranges)]
225 #[allow(clippy::single_match)]
226 impl<'de> _serde::de::Visitor<'de> for __hkpListShapeVisitor<'de> {
227 type Value = hkpListShape;
228 fn expecting(
229 &self,
230 __formatter: &mut core::fmt::Formatter,
231 ) -> core::fmt::Result {
232 core::fmt::Formatter::write_str(__formatter, "struct hkpListShape")
233 }
234 fn visit_struct_for_bytes<__A>(
235 self,
236 mut __map: __A,
237 ) -> _serde::__private::Result<Self::Value, __A::Error>
238 where
239 __A: _serde::de::MapAccess<'de>,
240 {
241 let __ptr = __A::class_ptr(&mut __map);
242 let parent = __A::parent_value(&mut __map)?;
243 let mut m_childInfo: _serde::__private::Option<
244 Vec<hkpListShapeChildInfo>,
245 > = _serde::__private::None;
246 let mut m_flags: _serde::__private::Option<u16> = _serde::__private::None;
247 let mut m_numDisabledChildren: _serde::__private::Option<u16> = _serde::__private::None;
248 let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
249 let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
250 let mut m_enabledChildren: _serde::__private::Option<
251 [u32; 8usize],
252 > = _serde::__private::None;
253 for i in 0..6usize {
254 match i {
255 0usize => {
256 if _serde::__private::Option::is_some(&m_childInfo) {
257 return _serde::__private::Err(
258 <__A::Error as _serde::de::Error>::duplicate_field(
259 "childInfo",
260 ),
261 );
262 }
263 m_childInfo = _serde::__private::Some(
264 match __A::next_value::<
265 Vec<hkpListShapeChildInfo>,
266 >(&mut __map) {
267 _serde::__private::Ok(__val) => __val,
268 _serde::__private::Err(__err) => {
269 return _serde::__private::Err(__err);
270 }
271 },
272 );
273 }
274 1usize => {
275 if _serde::__private::Option::is_some(&m_flags) {
276 return _serde::__private::Err(
277 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
278 );
279 }
280 m_flags = _serde::__private::Some(
281 match __A::next_value::<u16>(&mut __map) {
282 _serde::__private::Ok(__val) => __val,
283 _serde::__private::Err(__err) => {
284 return _serde::__private::Err(__err);
285 }
286 },
287 );
288 }
289 2usize => {
290 if _serde::__private::Option::is_some(
291 &m_numDisabledChildren,
292 ) {
293 return _serde::__private::Err(
294 <__A::Error as _serde::de::Error>::duplicate_field(
295 "numDisabledChildren",
296 ),
297 );
298 }
299 m_numDisabledChildren = _serde::__private::Some(
300 match __A::next_value::<u16>(&mut __map) {
301 _serde::__private::Ok(__val) => __val,
302 _serde::__private::Err(__err) => {
303 return _serde::__private::Err(__err);
304 }
305 },
306 );
307 }
308 3usize => {
309 if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
310 return _serde::__private::Err(
311 <__A::Error as _serde::de::Error>::duplicate_field(
312 "aabbHalfExtents",
313 ),
314 );
315 }
316 __A::pad(&mut __map, 8usize, 12usize)?;
317 m_aabbHalfExtents = _serde::__private::Some(
318 match __A::next_value::<Vector4>(&mut __map) {
319 _serde::__private::Ok(__val) => __val,
320 _serde::__private::Err(__err) => {
321 return _serde::__private::Err(__err);
322 }
323 },
324 );
325 }
326 4usize => {
327 if _serde::__private::Option::is_some(&m_aabbCenter) {
328 return _serde::__private::Err(
329 <__A::Error as _serde::de::Error>::duplicate_field(
330 "aabbCenter",
331 ),
332 );
333 }
334 m_aabbCenter = _serde::__private::Some(
335 match __A::next_value::<Vector4>(&mut __map) {
336 _serde::__private::Ok(__val) => __val,
337 _serde::__private::Err(__err) => {
338 return _serde::__private::Err(__err);
339 }
340 },
341 );
342 }
343 5usize => {
344 if _serde::__private::Option::is_some(&m_enabledChildren) {
345 return _serde::__private::Err(
346 <__A::Error as _serde::de::Error>::duplicate_field(
347 "enabledChildren",
348 ),
349 );
350 }
351 m_enabledChildren = _serde::__private::Some(
352 match __A::next_value::<[u32; 8usize]>(&mut __map) {
353 _serde::__private::Ok(__val) => __val,
354 _serde::__private::Err(__err) => {
355 return _serde::__private::Err(__err);
356 }
357 },
358 );
359 }
360 _ => {}
361 }
362 }
363 let m_childInfo = match m_childInfo {
364 _serde::__private::Some(__field) => __field,
365 _serde::__private::None => {
366 return _serde::__private::Err(
367 <__A::Error as _serde::de::Error>::missing_field(
368 "childInfo",
369 ),
370 );
371 }
372 };
373 let m_flags = match m_flags {
374 _serde::__private::Some(__field) => __field,
375 _serde::__private::None => {
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::missing_field("flags"),
378 );
379 }
380 };
381 let m_numDisabledChildren = match m_numDisabledChildren {
382 _serde::__private::Some(__field) => __field,
383 _serde::__private::None => {
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::missing_field(
386 "numDisabledChildren",
387 ),
388 );
389 }
390 };
391 let m_aabbHalfExtents = match m_aabbHalfExtents {
392 _serde::__private::Some(__field) => __field,
393 _serde::__private::None => {
394 return _serde::__private::Err(
395 <__A::Error as _serde::de::Error>::missing_field(
396 "aabbHalfExtents",
397 ),
398 );
399 }
400 };
401 let m_aabbCenter = match m_aabbCenter {
402 _serde::__private::Some(__field) => __field,
403 _serde::__private::None => {
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::missing_field(
406 "aabbCenter",
407 ),
408 );
409 }
410 };
411 let m_enabledChildren = match m_enabledChildren {
412 _serde::__private::Some(__field) => __field,
413 _serde::__private::None => {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::missing_field(
416 "enabledChildren",
417 ),
418 );
419 }
420 };
421 _serde::__private::Ok(hkpListShape {
422 __ptr,
423 parent,
424 m_childInfo,
425 m_flags,
426 m_numDisabledChildren,
427 m_aabbHalfExtents,
428 m_aabbCenter,
429 m_enabledChildren,
430 })
431 }
432 #[allow(clippy::manual_unwrap_or_default)]
433 fn visit_struct<__A>(
434 self,
435 mut __map: __A,
436 ) -> _serde::__private::Result<Self::Value, __A::Error>
437 where
438 __A: _serde::de::MapAccess<'de>,
439 {
440 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
441 let mut m_disableWelding: _serde::__private::Option<bool> = _serde::__private::None;
442 let mut m_collectionType: _serde::__private::Option<
443 CollectionType,
444 > = _serde::__private::None;
445 let mut m_childInfo: _serde::__private::Option<
446 Vec<hkpListShapeChildInfo>,
447 > = _serde::__private::None;
448 let mut m_flags: _serde::__private::Option<u16> = _serde::__private::None;
449 let mut m_numDisabledChildren: _serde::__private::Option<u16> = _serde::__private::None;
450 let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
451 let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
452 let mut m_enabledChildren: _serde::__private::Option<
453 [u32; 8usize],
454 > = _serde::__private::None;
455 while let _serde::__private::Some(__key) = {
456 __A::next_key::<__Field>(&mut __map)?
457 } {
458 match __key {
459 __Field::m_userData => {
460 #[cfg(
461 any(feature = "strict", feature = "ignore_duplicates")
462 )]
463 if _serde::__private::Option::is_some(&m_userData) {
464 #[cfg(feature = "ignore_duplicates")]
465 {
466 __A::skip_value(&mut __map)?;
467 continue;
468 }
469 #[cfg(feature = "strict")]
470 return _serde::__private::Err(
471 <__A::Error as _serde::de::Error>::duplicate_field(
472 "userData",
473 ),
474 );
475 }
476 m_userData = _serde::__private::Some(
477 match __A::next_value::<Ulong>(&mut __map) {
478 _serde::__private::Ok(__val) => __val,
479 _serde::__private::Err(__err) => {
480 return _serde::__private::Err(__err);
481 }
482 },
483 );
484 }
485 __Field::m_disableWelding => {
486 #[cfg(
487 any(feature = "strict", feature = "ignore_duplicates")
488 )]
489 if _serde::__private::Option::is_some(&m_disableWelding) {
490 #[cfg(feature = "ignore_duplicates")]
491 {
492 __A::skip_value(&mut __map)?;
493 continue;
494 }
495 #[cfg(feature = "strict")]
496 return _serde::__private::Err(
497 <__A::Error as _serde::de::Error>::duplicate_field(
498 "disableWelding",
499 ),
500 );
501 }
502 m_disableWelding = _serde::__private::Some(
503 match __A::next_value::<bool>(&mut __map) {
504 _serde::__private::Ok(__val) => __val,
505 _serde::__private::Err(__err) => {
506 return _serde::__private::Err(__err);
507 }
508 },
509 );
510 }
511 __Field::m_collectionType => {
512 #[cfg(
513 any(feature = "strict", feature = "ignore_duplicates")
514 )]
515 if _serde::__private::Option::is_some(&m_collectionType) {
516 #[cfg(feature = "ignore_duplicates")]
517 {
518 __A::skip_value(&mut __map)?;
519 continue;
520 }
521 #[cfg(feature = "strict")]
522 return _serde::__private::Err(
523 <__A::Error as _serde::de::Error>::duplicate_field(
524 "collectionType",
525 ),
526 );
527 }
528 m_collectionType = _serde::__private::Some(
529 match __A::next_value::<CollectionType>(&mut __map) {
530 _serde::__private::Ok(__val) => __val,
531 _serde::__private::Err(__err) => {
532 return _serde::__private::Err(__err);
533 }
534 },
535 );
536 }
537 __Field::m_childInfo => {
538 #[cfg(
539 any(feature = "strict", feature = "ignore_duplicates")
540 )]
541 if _serde::__private::Option::is_some(&m_childInfo) {
542 #[cfg(feature = "ignore_duplicates")]
543 {
544 __A::skip_value(&mut __map)?;
545 continue;
546 }
547 #[cfg(feature = "strict")]
548 return _serde::__private::Err(
549 <__A::Error as _serde::de::Error>::duplicate_field(
550 "childInfo",
551 ),
552 );
553 }
554 m_childInfo = _serde::__private::Some(
555 match __A::next_value::<
556 Vec<hkpListShapeChildInfo>,
557 >(&mut __map) {
558 _serde::__private::Ok(__val) => __val,
559 _serde::__private::Err(__err) => {
560 return _serde::__private::Err(__err);
561 }
562 },
563 );
564 }
565 __Field::m_flags => {
566 #[cfg(
567 any(feature = "strict", feature = "ignore_duplicates")
568 )]
569 if _serde::__private::Option::is_some(&m_flags) {
570 #[cfg(feature = "ignore_duplicates")]
571 {
572 __A::skip_value(&mut __map)?;
573 continue;
574 }
575 #[cfg(feature = "strict")]
576 return _serde::__private::Err(
577 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
578 );
579 }
580 m_flags = _serde::__private::Some(
581 match __A::next_value::<u16>(&mut __map) {
582 _serde::__private::Ok(__val) => __val,
583 _serde::__private::Err(__err) => {
584 return _serde::__private::Err(__err);
585 }
586 },
587 );
588 }
589 __Field::m_numDisabledChildren => {
590 #[cfg(
591 any(feature = "strict", feature = "ignore_duplicates")
592 )]
593 if _serde::__private::Option::is_some(
594 &m_numDisabledChildren,
595 ) {
596 #[cfg(feature = "ignore_duplicates")]
597 {
598 __A::skip_value(&mut __map)?;
599 continue;
600 }
601 #[cfg(feature = "strict")]
602 return _serde::__private::Err(
603 <__A::Error as _serde::de::Error>::duplicate_field(
604 "numDisabledChildren",
605 ),
606 );
607 }
608 m_numDisabledChildren = _serde::__private::Some(
609 match __A::next_value::<u16>(&mut __map) {
610 _serde::__private::Ok(__val) => __val,
611 _serde::__private::Err(__err) => {
612 return _serde::__private::Err(__err);
613 }
614 },
615 );
616 }
617 __Field::m_aabbHalfExtents => {
618 #[cfg(
619 any(feature = "strict", feature = "ignore_duplicates")
620 )]
621 if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
622 #[cfg(feature = "ignore_duplicates")]
623 {
624 __A::skip_value(&mut __map)?;
625 continue;
626 }
627 #[cfg(feature = "strict")]
628 return _serde::__private::Err(
629 <__A::Error as _serde::de::Error>::duplicate_field(
630 "aabbHalfExtents",
631 ),
632 );
633 }
634 m_aabbHalfExtents = _serde::__private::Some(
635 match __A::next_value::<Vector4>(&mut __map) {
636 _serde::__private::Ok(__val) => __val,
637 _serde::__private::Err(__err) => {
638 return _serde::__private::Err(__err);
639 }
640 },
641 );
642 }
643 __Field::m_aabbCenter => {
644 #[cfg(
645 any(feature = "strict", feature = "ignore_duplicates")
646 )]
647 if _serde::__private::Option::is_some(&m_aabbCenter) {
648 #[cfg(feature = "ignore_duplicates")]
649 {
650 __A::skip_value(&mut __map)?;
651 continue;
652 }
653 #[cfg(feature = "strict")]
654 return _serde::__private::Err(
655 <__A::Error as _serde::de::Error>::duplicate_field(
656 "aabbCenter",
657 ),
658 );
659 }
660 m_aabbCenter = _serde::__private::Some(
661 match __A::next_value::<Vector4>(&mut __map) {
662 _serde::__private::Ok(__val) => __val,
663 _serde::__private::Err(__err) => {
664 return _serde::__private::Err(__err);
665 }
666 },
667 );
668 }
669 __Field::m_enabledChildren => {
670 #[cfg(
671 any(feature = "strict", feature = "ignore_duplicates")
672 )]
673 if _serde::__private::Option::is_some(&m_enabledChildren) {
674 #[cfg(feature = "ignore_duplicates")]
675 {
676 __A::skip_value(&mut __map)?;
677 continue;
678 }
679 #[cfg(feature = "strict")]
680 return _serde::__private::Err(
681 <__A::Error as _serde::de::Error>::duplicate_field(
682 "enabledChildren",
683 ),
684 );
685 }
686 m_enabledChildren = _serde::__private::Some(
687 match __A::next_value::<[u32; 8usize]>(&mut __map) {
688 _serde::__private::Ok(__val) => __val,
689 _serde::__private::Err(__err) => {
690 return _serde::__private::Err(__err);
691 }
692 },
693 );
694 }
695 _ => __A::skip_value(&mut __map)?,
696 }
697 }
698 let m_userData = match m_userData {
699 _serde::__private::Some(__field) => __field,
700 _serde::__private::None => {
701 #[cfg(feature = "strict")]
702 return _serde::__private::Err(
703 <__A::Error as _serde::de::Error>::missing_field("userData"),
704 );
705 #[cfg(not(feature = "strict"))] Default::default()
706 }
707 };
708 let m_disableWelding = match m_disableWelding {
709 _serde::__private::Some(__field) => __field,
710 _serde::__private::None => {
711 #[cfg(feature = "strict")]
712 return _serde::__private::Err(
713 <__A::Error as _serde::de::Error>::missing_field(
714 "disableWelding",
715 ),
716 );
717 #[cfg(not(feature = "strict"))] Default::default()
718 }
719 };
720 let m_collectionType = match m_collectionType {
721 _serde::__private::Some(__field) => __field,
722 _serde::__private::None => {
723 #[cfg(feature = "strict")]
724 return _serde::__private::Err(
725 <__A::Error as _serde::de::Error>::missing_field(
726 "collectionType",
727 ),
728 );
729 #[cfg(not(feature = "strict"))] Default::default()
730 }
731 };
732 let m_childInfo = match m_childInfo {
733 _serde::__private::Some(__field) => __field,
734 _serde::__private::None => {
735 #[cfg(feature = "strict")]
736 return _serde::__private::Err(
737 <__A::Error as _serde::de::Error>::missing_field(
738 "childInfo",
739 ),
740 );
741 #[cfg(not(feature = "strict"))] Default::default()
742 }
743 };
744 let m_flags = match m_flags {
745 _serde::__private::Some(__field) => __field,
746 _serde::__private::None => {
747 #[cfg(feature = "strict")]
748 return _serde::__private::Err(
749 <__A::Error as _serde::de::Error>::missing_field("flags"),
750 );
751 #[cfg(not(feature = "strict"))] Default::default()
752 }
753 };
754 let m_numDisabledChildren = match m_numDisabledChildren {
755 _serde::__private::Some(__field) => __field,
756 _serde::__private::None => {
757 #[cfg(feature = "strict")]
758 return _serde::__private::Err(
759 <__A::Error as _serde::de::Error>::missing_field(
760 "numDisabledChildren",
761 ),
762 );
763 #[cfg(not(feature = "strict"))] Default::default()
764 }
765 };
766 let m_aabbHalfExtents = match m_aabbHalfExtents {
767 _serde::__private::Some(__field) => __field,
768 _serde::__private::None => {
769 #[cfg(feature = "strict")]
770 return _serde::__private::Err(
771 <__A::Error as _serde::de::Error>::missing_field(
772 "aabbHalfExtents",
773 ),
774 );
775 #[cfg(not(feature = "strict"))] Default::default()
776 }
777 };
778 let m_aabbCenter = match m_aabbCenter {
779 _serde::__private::Some(__field) => __field,
780 _serde::__private::None => {
781 #[cfg(feature = "strict")]
782 return _serde::__private::Err(
783 <__A::Error as _serde::de::Error>::missing_field(
784 "aabbCenter",
785 ),
786 );
787 #[cfg(not(feature = "strict"))] Default::default()
788 }
789 };
790 let m_enabledChildren = match m_enabledChildren {
791 _serde::__private::Some(__field) => __field,
792 _serde::__private::None => {
793 #[cfg(feature = "strict")]
794 return _serde::__private::Err(
795 <__A::Error as _serde::de::Error>::missing_field(
796 "enabledChildren",
797 ),
798 );
799 #[cfg(not(feature = "strict"))] Default::default()
800 }
801 };
802 let __ptr = None;
803 let parent = hkBaseObject { __ptr };
804 let parent = hkReferencedObject {
805 __ptr,
806 parent,
807 ..Default::default()
808 };
809 let parent = hkpShape {
810 __ptr,
811 parent,
812 m_userData,
813 ..Default::default()
814 };
815 let parent = hkpShapeCollection {
816 __ptr,
817 parent,
818 m_disableWelding,
819 m_collectionType,
820 };
821 let __ptr = __A::class_ptr(&mut __map);
822 _serde::__private::Ok(hkpListShape {
823 __ptr,
824 parent,
825 m_childInfo,
826 m_flags,
827 m_numDisabledChildren,
828 m_aabbHalfExtents,
829 m_aabbCenter,
830 m_enabledChildren,
831 })
832 }
833 }
834 const FIELDS: &[&str] = &[
835 "childInfo",
836 "flags",
837 "numDisabledChildren",
838 "aabbHalfExtents",
839 "aabbCenter",
840 "enabledChildren",
841 ];
842 _serde::Deserializer::deserialize_struct(
843 deserializer,
844 "hkpListShape",
845 FIELDS,
846 __hkpListShapeVisitor {
847 marker: _serde::__private::PhantomData::<hkpListShape>,
848 lifetime: _serde::__private::PhantomData,
849 },
850 )
851 }
852 }
853};