havok_classes/generated/
hkpConvexListShape_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpConvexListShape`
5/// - version: `0`
6/// - signature: `0x450b26e8`
7/// - size: ` 80`(x86)/`128`(x86_64)
8/// -  vtable: `true`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkpConvexShape,
30    /// # C++ Info
31    /// - name: `minDistanceToUseConvexHullForGetClosestPoints`(ctype: `hkReal`)
32    /// - offset: ` 24`(x86)/` 48`(x86_64)
33    /// - type_size: `  4`(x86)/`  4`(x86_64)
34    #[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    /// # C++ Info
44    /// - name: `aabbHalfExtents`(ctype: `hkVector4`)
45    /// - offset: ` 32`(x86)/` 64`(x86_64)
46    /// - type_size: ` 16`(x86)/` 16`(x86_64)
47    #[cfg_attr(feature = "json_schema", schemars(rename = "aabbHalfExtents"))]
48    #[cfg_attr(feature = "serde", serde(rename = "aabbHalfExtents"))]
49    pub m_aabbHalfExtents: Vector4,
50    /// # C++ Info
51    /// - name: `aabbCenter`(ctype: `hkVector4`)
52    /// - offset: ` 48`(x86)/` 80`(x86_64)
53    /// - type_size: ` 16`(x86)/` 16`(x86_64)
54    #[cfg_attr(feature = "json_schema", schemars(rename = "aabbCenter"))]
55    #[cfg_attr(feature = "serde", serde(rename = "aabbCenter"))]
56    pub m_aabbCenter: Vector4,
57    /// # C++ Info
58    /// - name: `useCachedAabb`(ctype: `hkBool`)
59    /// - offset: ` 64`(x86)/` 96`(x86_64)
60    /// - type_size: `  1`(x86)/`  1`(x86_64)
61    #[cfg_attr(feature = "json_schema", schemars(rename = "useCachedAabb"))]
62    #[cfg_attr(feature = "serde", serde(rename = "useCachedAabb"))]
63    pub m_useCachedAabb: bool,
64    /// # C++ Info
65    /// - name: `childShapes`(ctype: `hkArray<hkpConvexShape*>`)
66    /// - offset: ` 68`(x86)/`104`(x86_64)
67    /// - type_size: ` 12`(x86)/` 16`(x86_64)
68    #[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                /// Intended for use in XML.
171                #[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};