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 hkpConvexListShape {
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: hkpConvexShape,
30 #[cfg_attr(
35 feature = "json_schema",
36 schemars(rename = "minDistanceToUseConvexHullForGetClosestPoints")
37 )]
38 #[cfg_attr(
39 feature = "serde",
40 serde(rename = "minDistanceToUseConvexHullForGetClosestPoints")
41 )]
42 pub m_minDistanceToUseConvexHullForGetClosestPoints: f32,
43 #[cfg_attr(feature = "json_schema", schemars(rename = "aabbHalfExtents"))]
48 #[cfg_attr(feature = "serde", serde(rename = "aabbHalfExtents"))]
49 pub m_aabbHalfExtents: Vector4,
50 #[cfg_attr(feature = "json_schema", schemars(rename = "aabbCenter"))]
55 #[cfg_attr(feature = "serde", serde(rename = "aabbCenter"))]
56 pub m_aabbCenter: Vector4,
57 #[cfg_attr(feature = "json_schema", schemars(rename = "useCachedAabb"))]
62 #[cfg_attr(feature = "serde", serde(rename = "useCachedAabb"))]
63 pub m_useCachedAabb: bool,
64 #[cfg_attr(feature = "json_schema", schemars(rename = "childShapes"))]
69 #[cfg_attr(feature = "serde", serde(rename = "childShapes"))]
70 pub m_childShapes: Vec<Pointer>,
71}
72const _: () = {
73 use havok_serde as _serde;
74 impl _serde::HavokClass for hkpConvexListShape {
75 #[inline]
76 fn name(&self) -> &'static str {
77 "hkpConvexListShape"
78 }
79 #[inline]
80 fn signature(&self) -> _serde::__private::Signature {
81 _serde::__private::Signature::new(0x450b26e8)
82 }
83 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
84 fn deps_indexes(&self) -> Vec<usize> {
85 let mut v = Vec::new();
86 v.extend(self.m_childShapes.iter().map(|ptr| ptr.get()));
87 v
88 }
89 }
90 impl _serde::Serialize for hkpConvexListShape {
91 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
92 where
93 S: _serde::ser::Serializer,
94 {
95 let class_meta = self
96 .__ptr
97 .map(|name| (name, _serde::__private::Signature::new(0x450b26e8)));
98 let mut serializer = __serializer
99 .serialize_struct("hkpConvexListShape", class_meta, (80u64, 128u64))?;
100 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
101 serializer
102 .skip_field(
103 "memSizeAndFlags",
104 &self.parent.parent.parent.parent.m_memSizeAndFlags,
105 )?;
106 serializer
107 .skip_field(
108 "referenceCount",
109 &self.parent.parent.parent.parent.m_referenceCount,
110 )?;
111 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
112 serializer
113 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
114 serializer.skip_field("type", &self.parent.parent.parent.m_type)?;
115 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
116 serializer.serialize_field("radius", &self.parent.m_radius)?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
119 serializer
120 .serialize_field(
121 "minDistanceToUseConvexHullForGetClosestPoints",
122 &self.m_minDistanceToUseConvexHullForGetClosestPoints,
123 )?;
124 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 12usize].as_slice())?;
125 serializer.serialize_field("aabbHalfExtents", &self.m_aabbHalfExtents)?;
126 serializer.serialize_field("aabbCenter", &self.m_aabbCenter)?;
127 serializer.serialize_field("useCachedAabb", &self.m_useCachedAabb)?;
128 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
129 serializer
130 .serialize_array_field(
131 "childShapes",
132 &self.m_childShapes,
133 TypeSize::NonPtr,
134 )?;
135 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 8usize].as_slice())?;
136 serializer.end()
137 }
138 }
139};
140#[doc(hidden)]
141#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
142const _: () = {
143 use havok_serde as _serde;
144 #[automatically_derived]
145 impl<'de> _serde::Deserialize<'de> for hkpConvexListShape {
146 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
147 where
148 __D: _serde::Deserializer<'de>,
149 {
150 #[allow(non_camel_case_types)]
151 enum __Field {
152 m_userData,
153 m_radius,
154 m_minDistanceToUseConvexHullForGetClosestPoints,
155 m_aabbHalfExtents,
156 m_aabbCenter,
157 m_useCachedAabb,
158 m_childShapes,
159 __ignore,
160 }
161 struct __FieldVisitor;
162 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
163 type Value = __Field;
164 fn expecting(
165 &self,
166 __formatter: &mut core::fmt::Formatter,
167 ) -> core::fmt::Result {
168 core::fmt::Formatter::write_str(__formatter, "field identifier")
169 }
170 #[allow(clippy::match_single_binding)]
172 #[allow(clippy::reversed_empty_ranges)]
173 #[allow(clippy::single_match)]
174 fn visit_key<__E>(
175 self,
176 __value: &str,
177 ) -> core::result::Result<Self::Value, __E>
178 where
179 __E: _serde::de::Error,
180 {
181 match __value {
182 "userData" => Ok(__Field::m_userData),
183 "radius" => Ok(__Field::m_radius),
184 "minDistanceToUseConvexHullForGetClosestPoints" => {
185 Ok(__Field::m_minDistanceToUseConvexHullForGetClosestPoints)
186 }
187 "aabbHalfExtents" => Ok(__Field::m_aabbHalfExtents),
188 "aabbCenter" => Ok(__Field::m_aabbCenter),
189 "useCachedAabb" => Ok(__Field::m_useCachedAabb),
190 "childShapes" => Ok(__Field::m_childShapes),
191 _ => Ok(__Field::__ignore),
192 }
193 }
194 }
195 impl<'de> _serde::Deserialize<'de> for __Field {
196 #[inline]
197 fn deserialize<__D>(
198 __deserializer: __D,
199 ) -> core::result::Result<Self, __D::Error>
200 where
201 __D: _serde::Deserializer<'de>,
202 {
203 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
204 }
205 }
206 struct __hkpConvexListShapeVisitor<'de> {
207 marker: _serde::__private::PhantomData<hkpConvexListShape>,
208 lifetime: _serde::__private::PhantomData<&'de ()>,
209 }
210 #[allow(clippy::match_single_binding)]
211 #[allow(clippy::reversed_empty_ranges)]
212 #[allow(clippy::single_match)]
213 impl<'de> _serde::de::Visitor<'de> for __hkpConvexListShapeVisitor<'de> {
214 type Value = hkpConvexListShape;
215 fn expecting(
216 &self,
217 __formatter: &mut core::fmt::Formatter,
218 ) -> core::fmt::Result {
219 core::fmt::Formatter::write_str(
220 __formatter,
221 "struct hkpConvexListShape",
222 )
223 }
224 fn visit_struct_for_bytes<__A>(
225 self,
226 mut __map: __A,
227 ) -> _serde::__private::Result<Self::Value, __A::Error>
228 where
229 __A: _serde::de::MapAccess<'de>,
230 {
231 let __ptr = __A::class_ptr(&mut __map);
232 let parent = __A::parent_value(&mut __map)?;
233 let mut m_minDistanceToUseConvexHullForGetClosestPoints: _serde::__private::Option<
234 f32,
235 > = _serde::__private::None;
236 let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
237 let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
238 let mut m_useCachedAabb: _serde::__private::Option<bool> = _serde::__private::None;
239 let mut m_childShapes: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
240 for i in 0..5usize {
241 match i {
242 0usize => {
243 if _serde::__private::Option::is_some(
244 &m_minDistanceToUseConvexHullForGetClosestPoints,
245 ) {
246 return _serde::__private::Err(
247 <__A::Error as _serde::de::Error>::duplicate_field(
248 "minDistanceToUseConvexHullForGetClosestPoints",
249 ),
250 );
251 }
252 __A::pad(&mut __map, 4usize, 8usize)?;
253 m_minDistanceToUseConvexHullForGetClosestPoints = _serde::__private::Some(
254 match __A::next_value::<f32>(&mut __map) {
255 _serde::__private::Ok(__val) => __val,
256 _serde::__private::Err(__err) => {
257 return _serde::__private::Err(__err);
258 }
259 },
260 );
261 }
262 1usize => {
263 if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
264 return _serde::__private::Err(
265 <__A::Error as _serde::de::Error>::duplicate_field(
266 "aabbHalfExtents",
267 ),
268 );
269 }
270 __A::pad(&mut __map, 4usize, 12usize)?;
271 m_aabbHalfExtents = _serde::__private::Some(
272 match __A::next_value::<Vector4>(&mut __map) {
273 _serde::__private::Ok(__val) => __val,
274 _serde::__private::Err(__err) => {
275 return _serde::__private::Err(__err);
276 }
277 },
278 );
279 }
280 2usize => {
281 if _serde::__private::Option::is_some(&m_aabbCenter) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field(
284 "aabbCenter",
285 ),
286 );
287 }
288 m_aabbCenter = _serde::__private::Some(
289 match __A::next_value::<Vector4>(&mut __map) {
290 _serde::__private::Ok(__val) => __val,
291 _serde::__private::Err(__err) => {
292 return _serde::__private::Err(__err);
293 }
294 },
295 );
296 }
297 3usize => {
298 if _serde::__private::Option::is_some(&m_useCachedAabb) {
299 return _serde::__private::Err(
300 <__A::Error as _serde::de::Error>::duplicate_field(
301 "useCachedAabb",
302 ),
303 );
304 }
305 m_useCachedAabb = _serde::__private::Some(
306 match __A::next_value::<bool>(&mut __map) {
307 _serde::__private::Ok(__val) => __val,
308 _serde::__private::Err(__err) => {
309 return _serde::__private::Err(__err);
310 }
311 },
312 );
313 }
314 4usize => {
315 if _serde::__private::Option::is_some(&m_childShapes) {
316 return _serde::__private::Err(
317 <__A::Error as _serde::de::Error>::duplicate_field(
318 "childShapes",
319 ),
320 );
321 }
322 __A::pad(&mut __map, 3usize, 7usize)?;
323 m_childShapes = _serde::__private::Some(
324 match __A::next_value::<Vec<Pointer>>(&mut __map) {
325 _serde::__private::Ok(__val) => __val,
326 _serde::__private::Err(__err) => {
327 return _serde::__private::Err(__err);
328 }
329 },
330 );
331 }
332 _ => {}
333 }
334 }
335 __A::pad(&mut __map, 0usize, 8usize)?;
336 let m_minDistanceToUseConvexHullForGetClosestPoints = match m_minDistanceToUseConvexHullForGetClosestPoints {
337 _serde::__private::Some(__field) => __field,
338 _serde::__private::None => {
339 return _serde::__private::Err(
340 <__A::Error as _serde::de::Error>::missing_field(
341 "minDistanceToUseConvexHullForGetClosestPoints",
342 ),
343 );
344 }
345 };
346 let m_aabbHalfExtents = match m_aabbHalfExtents {
347 _serde::__private::Some(__field) => __field,
348 _serde::__private::None => {
349 return _serde::__private::Err(
350 <__A::Error as _serde::de::Error>::missing_field(
351 "aabbHalfExtents",
352 ),
353 );
354 }
355 };
356 let m_aabbCenter = match m_aabbCenter {
357 _serde::__private::Some(__field) => __field,
358 _serde::__private::None => {
359 return _serde::__private::Err(
360 <__A::Error as _serde::de::Error>::missing_field(
361 "aabbCenter",
362 ),
363 );
364 }
365 };
366 let m_useCachedAabb = match m_useCachedAabb {
367 _serde::__private::Some(__field) => __field,
368 _serde::__private::None => {
369 return _serde::__private::Err(
370 <__A::Error as _serde::de::Error>::missing_field(
371 "useCachedAabb",
372 ),
373 );
374 }
375 };
376 let m_childShapes = match m_childShapes {
377 _serde::__private::Some(__field) => __field,
378 _serde::__private::None => {
379 return _serde::__private::Err(
380 <__A::Error as _serde::de::Error>::missing_field(
381 "childShapes",
382 ),
383 );
384 }
385 };
386 _serde::__private::Ok(hkpConvexListShape {
387 __ptr,
388 parent,
389 m_minDistanceToUseConvexHullForGetClosestPoints,
390 m_aabbHalfExtents,
391 m_aabbCenter,
392 m_useCachedAabb,
393 m_childShapes,
394 })
395 }
396 #[allow(clippy::manual_unwrap_or_default)]
397 fn visit_struct<__A>(
398 self,
399 mut __map: __A,
400 ) -> _serde::__private::Result<Self::Value, __A::Error>
401 where
402 __A: _serde::de::MapAccess<'de>,
403 {
404 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
405 let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
406 let mut m_minDistanceToUseConvexHullForGetClosestPoints: _serde::__private::Option<
407 f32,
408 > = _serde::__private::None;
409 let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
410 let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
411 let mut m_useCachedAabb: _serde::__private::Option<bool> = _serde::__private::None;
412 let mut m_childShapes: _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_radius => {
444 #[cfg(
445 any(feature = "strict", feature = "ignore_duplicates")
446 )]
447 if _serde::__private::Option::is_some(&m_radius) {
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("radius"),
456 );
457 }
458 m_radius = _serde::__private::Some(
459 match __A::next_value::<f32>(&mut __map) {
460 _serde::__private::Ok(__val) => __val,
461 _serde::__private::Err(__err) => {
462 return _serde::__private::Err(__err);
463 }
464 },
465 );
466 }
467 __Field::m_minDistanceToUseConvexHullForGetClosestPoints => {
468 #[cfg(
469 any(feature = "strict", feature = "ignore_duplicates")
470 )]
471 if _serde::__private::Option::is_some(
472 &m_minDistanceToUseConvexHullForGetClosestPoints,
473 ) {
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 "minDistanceToUseConvexHullForGetClosestPoints",
483 ),
484 );
485 }
486 m_minDistanceToUseConvexHullForGetClosestPoints = _serde::__private::Some(
487 match __A::next_value::<f32>(&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_aabbHalfExtents => {
496 #[cfg(
497 any(feature = "strict", feature = "ignore_duplicates")
498 )]
499 if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
500 #[cfg(feature = "ignore_duplicates")]
501 {
502 __A::skip_value(&mut __map)?;
503 continue;
504 }
505 #[cfg(feature = "strict")]
506 return _serde::__private::Err(
507 <__A::Error as _serde::de::Error>::duplicate_field(
508 "aabbHalfExtents",
509 ),
510 );
511 }
512 m_aabbHalfExtents = _serde::__private::Some(
513 match __A::next_value::<Vector4>(&mut __map) {
514 _serde::__private::Ok(__val) => __val,
515 _serde::__private::Err(__err) => {
516 return _serde::__private::Err(__err);
517 }
518 },
519 );
520 }
521 __Field::m_aabbCenter => {
522 #[cfg(
523 any(feature = "strict", feature = "ignore_duplicates")
524 )]
525 if _serde::__private::Option::is_some(&m_aabbCenter) {
526 #[cfg(feature = "ignore_duplicates")]
527 {
528 __A::skip_value(&mut __map)?;
529 continue;
530 }
531 #[cfg(feature = "strict")]
532 return _serde::__private::Err(
533 <__A::Error as _serde::de::Error>::duplicate_field(
534 "aabbCenter",
535 ),
536 );
537 }
538 m_aabbCenter = _serde::__private::Some(
539 match __A::next_value::<Vector4>(&mut __map) {
540 _serde::__private::Ok(__val) => __val,
541 _serde::__private::Err(__err) => {
542 return _serde::__private::Err(__err);
543 }
544 },
545 );
546 }
547 __Field::m_useCachedAabb => {
548 #[cfg(
549 any(feature = "strict", feature = "ignore_duplicates")
550 )]
551 if _serde::__private::Option::is_some(&m_useCachedAabb) {
552 #[cfg(feature = "ignore_duplicates")]
553 {
554 __A::skip_value(&mut __map)?;
555 continue;
556 }
557 #[cfg(feature = "strict")]
558 return _serde::__private::Err(
559 <__A::Error as _serde::de::Error>::duplicate_field(
560 "useCachedAabb",
561 ),
562 );
563 }
564 m_useCachedAabb = _serde::__private::Some(
565 match __A::next_value::<bool>(&mut __map) {
566 _serde::__private::Ok(__val) => __val,
567 _serde::__private::Err(__err) => {
568 return _serde::__private::Err(__err);
569 }
570 },
571 );
572 }
573 __Field::m_childShapes => {
574 #[cfg(
575 any(feature = "strict", feature = "ignore_duplicates")
576 )]
577 if _serde::__private::Option::is_some(&m_childShapes) {
578 #[cfg(feature = "ignore_duplicates")]
579 {
580 __A::skip_value(&mut __map)?;
581 continue;
582 }
583 #[cfg(feature = "strict")]
584 return _serde::__private::Err(
585 <__A::Error as _serde::de::Error>::duplicate_field(
586 "childShapes",
587 ),
588 );
589 }
590 m_childShapes = _serde::__private::Some(
591 match __A::next_value::<Vec<Pointer>>(&mut __map) {
592 _serde::__private::Ok(__val) => __val,
593 _serde::__private::Err(__err) => {
594 return _serde::__private::Err(__err);
595 }
596 },
597 );
598 }
599 _ => __A::skip_value(&mut __map)?,
600 }
601 }
602 let m_userData = match m_userData {
603 _serde::__private::Some(__field) => __field,
604 _serde::__private::None => {
605 #[cfg(feature = "strict")]
606 return _serde::__private::Err(
607 <__A::Error as _serde::de::Error>::missing_field("userData"),
608 );
609 #[cfg(not(feature = "strict"))] Default::default()
610 }
611 };
612 let m_radius = match m_radius {
613 _serde::__private::Some(__field) => __field,
614 _serde::__private::None => {
615 #[cfg(feature = "strict")]
616 return _serde::__private::Err(
617 <__A::Error as _serde::de::Error>::missing_field("radius"),
618 );
619 #[cfg(not(feature = "strict"))] Default::default()
620 }
621 };
622 let m_minDistanceToUseConvexHullForGetClosestPoints = match m_minDistanceToUseConvexHullForGetClosestPoints {
623 _serde::__private::Some(__field) => __field,
624 _serde::__private::None => {
625 #[cfg(feature = "strict")]
626 return _serde::__private::Err(
627 <__A::Error as _serde::de::Error>::missing_field(
628 "minDistanceToUseConvexHullForGetClosestPoints",
629 ),
630 );
631 #[cfg(not(feature = "strict"))] Default::default()
632 }
633 };
634 let m_aabbHalfExtents = match m_aabbHalfExtents {
635 _serde::__private::Some(__field) => __field,
636 _serde::__private::None => {
637 #[cfg(feature = "strict")]
638 return _serde::__private::Err(
639 <__A::Error as _serde::de::Error>::missing_field(
640 "aabbHalfExtents",
641 ),
642 );
643 #[cfg(not(feature = "strict"))] Default::default()
644 }
645 };
646 let m_aabbCenter = match m_aabbCenter {
647 _serde::__private::Some(__field) => __field,
648 _serde::__private::None => {
649 #[cfg(feature = "strict")]
650 return _serde::__private::Err(
651 <__A::Error as _serde::de::Error>::missing_field(
652 "aabbCenter",
653 ),
654 );
655 #[cfg(not(feature = "strict"))] Default::default()
656 }
657 };
658 let m_useCachedAabb = match m_useCachedAabb {
659 _serde::__private::Some(__field) => __field,
660 _serde::__private::None => {
661 #[cfg(feature = "strict")]
662 return _serde::__private::Err(
663 <__A::Error as _serde::de::Error>::missing_field(
664 "useCachedAabb",
665 ),
666 );
667 #[cfg(not(feature = "strict"))] Default::default()
668 }
669 };
670 let m_childShapes = match m_childShapes {
671 _serde::__private::Some(__field) => __field,
672 _serde::__private::None => {
673 #[cfg(feature = "strict")]
674 return _serde::__private::Err(
675 <__A::Error as _serde::de::Error>::missing_field(
676 "childShapes",
677 ),
678 );
679 #[cfg(not(feature = "strict"))] Default::default()
680 }
681 };
682 let __ptr = None;
683 let parent = hkBaseObject { __ptr };
684 let parent = hkReferencedObject {
685 __ptr,
686 parent,
687 ..Default::default()
688 };
689 let parent = hkpShape {
690 __ptr,
691 parent,
692 m_userData,
693 ..Default::default()
694 };
695 let parent = hkpSphereRepShape { __ptr, parent };
696 let parent = hkpConvexShape {
697 __ptr,
698 parent,
699 m_radius,
700 };
701 let __ptr = __A::class_ptr(&mut __map);
702 _serde::__private::Ok(hkpConvexListShape {
703 __ptr,
704 parent,
705 m_minDistanceToUseConvexHullForGetClosestPoints,
706 m_aabbHalfExtents,
707 m_aabbCenter,
708 m_useCachedAabb,
709 m_childShapes,
710 })
711 }
712 }
713 const FIELDS: &[&str] = &[
714 "minDistanceToUseConvexHullForGetClosestPoints",
715 "aabbHalfExtents",
716 "aabbCenter",
717 "useCachedAabb",
718 "childShapes",
719 ];
720 _serde::Deserializer::deserialize_struct(
721 deserializer,
722 "hkpConvexListShape",
723 FIELDS,
724 __hkpConvexListShapeVisitor {
725 marker: _serde::__private::PhantomData::<hkpConvexListShape>,
726 lifetime: _serde::__private::PhantomData,
727 },
728 )
729 }
730 }
731};