havok_classes/generated/
hkpListShape_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpListShape`
5/// - version: `0`
6/// - signature: `0xa1937cbd`
7/// - size: `112`(x86)/`144`(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 hkpListShape {
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: hkpShapeCollection,
30    /// # C++ Info
31    /// - name: `childInfo`(ctype: `hkArray<struct hkpListShapeChildInfo>`)
32    /// - offset: ` 24`(x86)/` 48`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "childInfo"))]
35    #[cfg_attr(feature = "serde", serde(rename = "childInfo"))]
36    pub m_childInfo: Vec<hkpListShapeChildInfo>,
37    /// # C++ Info
38    /// - name: `flags`(ctype: `hkUint16`)
39    /// - offset: ` 36`(x86)/` 64`(x86_64)
40    /// - type_size: `  2`(x86)/`  2`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
42    #[cfg_attr(feature = "serde", serde(rename = "flags"))]
43    pub m_flags: u16,
44    /// # C++ Info
45    /// - name: `numDisabledChildren`(ctype: `hkUint16`)
46    /// - offset: ` 38`(x86)/` 66`(x86_64)
47    /// - type_size: `  2`(x86)/`  2`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "numDisabledChildren"))]
49    #[cfg_attr(feature = "serde", serde(rename = "numDisabledChildren"))]
50    pub m_numDisabledChildren: u16,
51    /// # C++ Info
52    /// - name: `aabbHalfExtents`(ctype: `hkVector4`)
53    /// - offset: ` 48`(x86)/` 80`(x86_64)
54    /// - type_size: ` 16`(x86)/` 16`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "aabbHalfExtents"))]
56    #[cfg_attr(feature = "serde", serde(rename = "aabbHalfExtents"))]
57    pub m_aabbHalfExtents: Vector4,
58    /// # C++ Info
59    /// - name: `aabbCenter`(ctype: `hkVector4`)
60    /// - offset: ` 64`(x86)/` 96`(x86_64)
61    /// - type_size: ` 16`(x86)/` 16`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "aabbCenter"))]
63    #[cfg_attr(feature = "serde", serde(rename = "aabbCenter"))]
64    pub m_aabbCenter: Vector4,
65    /// # C++ Info
66    /// - name: `enabledChildren`(ctype: `hkUint32[8]`)
67    /// - offset: ` 80`(x86)/`112`(x86_64)
68    /// - type_size: ` 32`(x86)/` 32`(x86_64)
69    #[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                /// Intended for use in XML.
184                #[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};