havok_classes/generated/
hkpCompressedMeshShape_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpCompressedMeshShape`
5/// - version: `9`
6/// - signature: `0xa62d5e6e`
7/// - size: `224`(x86)/`304`(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 hkpCompressedMeshShape<'a> {
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: `bitsPerIndex`(ctype: `hkInt32`)
32    /// - offset: ` 24`(x86)/` 48`(x86_64)
33    /// - type_size: `  4`(x86)/`  4`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "bitsPerIndex"))]
35    #[cfg_attr(feature = "serde", serde(rename = "bitsPerIndex"))]
36    pub m_bitsPerIndex: i32,
37    /// # C++ Info
38    /// - name: `bitsPerWIndex`(ctype: `hkInt32`)
39    /// - offset: ` 28`(x86)/` 52`(x86_64)
40    /// - type_size: `  4`(x86)/`  4`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "bitsPerWIndex"))]
42    #[cfg_attr(feature = "serde", serde(rename = "bitsPerWIndex"))]
43    pub m_bitsPerWIndex: i32,
44    /// # C++ Info
45    /// - name: `wIndexMask`(ctype: `hkInt32`)
46    /// - offset: ` 32`(x86)/` 56`(x86_64)
47    /// - type_size: `  4`(x86)/`  4`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "wIndexMask"))]
49    #[cfg_attr(feature = "serde", serde(rename = "wIndexMask"))]
50    pub m_wIndexMask: i32,
51    /// # C++ Info
52    /// - name: `indexMask`(ctype: `hkInt32`)
53    /// - offset: ` 36`(x86)/` 60`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "indexMask"))]
56    #[cfg_attr(feature = "serde", serde(rename = "indexMask"))]
57    pub m_indexMask: i32,
58    /// # C++ Info
59    /// - name: `radius`(ctype: `hkReal`)
60    /// - offset: ` 40`(x86)/` 64`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "radius"))]
63    #[cfg_attr(feature = "serde", serde(rename = "radius"))]
64    pub m_radius: f32,
65    /// # C++ Info
66    /// - name: `weldingType`(ctype: `enum WeldingType`)
67    /// - offset: ` 44`(x86)/` 68`(x86_64)
68    /// - type_size: `  1`(x86)/`  1`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "weldingType"))]
70    #[cfg_attr(feature = "serde", serde(rename = "weldingType"))]
71    pub m_weldingType: WeldingType,
72    /// # C++ Info
73    /// - name: `materialType`(ctype: `enum MaterialType`)
74    /// - offset: ` 45`(x86)/` 69`(x86_64)
75    /// - type_size: `  1`(x86)/`  1`(x86_64)
76    #[cfg_attr(feature = "json_schema", schemars(rename = "materialType"))]
77    #[cfg_attr(feature = "serde", serde(rename = "materialType"))]
78    pub m_materialType: MaterialType,
79    /// # C++ Info
80    /// - name: `materials`(ctype: `hkArray<hkUint32>`)
81    /// - offset: ` 48`(x86)/` 72`(x86_64)
82    /// - type_size: ` 12`(x86)/` 16`(x86_64)
83    #[cfg_attr(feature = "json_schema", schemars(rename = "materials"))]
84    #[cfg_attr(feature = "serde", serde(rename = "materials"))]
85    pub m_materials: Vec<u32>,
86    /// # C++ Info
87    /// - name: `materials16`(ctype: `hkArray<hkUint16>`)
88    /// - offset: ` 60`(x86)/` 88`(x86_64)
89    /// - type_size: ` 12`(x86)/` 16`(x86_64)
90    #[cfg_attr(feature = "json_schema", schemars(rename = "materials16"))]
91    #[cfg_attr(feature = "serde", serde(rename = "materials16"))]
92    pub m_materials16: Vec<u16>,
93    /// # C++ Info
94    /// - name: `materials8`(ctype: `hkArray<hkUint8>`)
95    /// - offset: ` 72`(x86)/`104`(x86_64)
96    /// - type_size: ` 12`(x86)/` 16`(x86_64)
97    #[cfg_attr(feature = "json_schema", schemars(rename = "materials8"))]
98    #[cfg_attr(feature = "serde", serde(rename = "materials8"))]
99    pub m_materials8: Vec<u8>,
100    /// # C++ Info
101    /// - name: `transforms`(ctype: `hkArray<hkQsTransform>`)
102    /// - offset: ` 84`(x86)/`120`(x86_64)
103    /// - type_size: ` 12`(x86)/` 16`(x86_64)
104    #[cfg_attr(feature = "json_schema", schemars(rename = "transforms"))]
105    #[cfg_attr(feature = "serde", serde(rename = "transforms"))]
106    pub m_transforms: Vec<QsTransform>,
107    /// # C++ Info
108    /// - name: `bigVertices`(ctype: `hkArray<hkVector4>`)
109    /// - offset: ` 96`(x86)/`136`(x86_64)
110    /// - type_size: ` 12`(x86)/` 16`(x86_64)
111    #[cfg_attr(feature = "json_schema", schemars(rename = "bigVertices"))]
112    #[cfg_attr(feature = "serde", serde(rename = "bigVertices"))]
113    pub m_bigVertices: Vec<Vector4>,
114    /// # C++ Info
115    /// - name: `bigTriangles`(ctype: `hkArray<struct hkpCompressedMeshShapeBigTriangle>`)
116    /// - offset: `108`(x86)/`152`(x86_64)
117    /// - type_size: ` 12`(x86)/` 16`(x86_64)
118    #[cfg_attr(feature = "json_schema", schemars(rename = "bigTriangles"))]
119    #[cfg_attr(feature = "serde", serde(rename = "bigTriangles"))]
120    pub m_bigTriangles: Vec<hkpCompressedMeshShapeBigTriangle>,
121    /// # C++ Info
122    /// - name: `chunks`(ctype: `hkArray<struct hkpCompressedMeshShapeChunk>`)
123    /// - offset: `120`(x86)/`168`(x86_64)
124    /// - type_size: ` 12`(x86)/` 16`(x86_64)
125    #[cfg_attr(feature = "json_schema", schemars(rename = "chunks"))]
126    #[cfg_attr(feature = "serde", serde(rename = "chunks"))]
127    pub m_chunks: Vec<hkpCompressedMeshShapeChunk>,
128    /// # C++ Info
129    /// - name: `convexPieces`(ctype: `hkArray<struct hkpCompressedMeshShapeConvexPiece>`)
130    /// - offset: `132`(x86)/`184`(x86_64)
131    /// - type_size: ` 12`(x86)/` 16`(x86_64)
132    #[cfg_attr(feature = "json_schema", schemars(rename = "convexPieces"))]
133    #[cfg_attr(feature = "serde", serde(rename = "convexPieces"))]
134    pub m_convexPieces: Vec<hkpCompressedMeshShapeConvexPiece>,
135    /// # C++ Info
136    /// - name: `error`(ctype: `hkReal`)
137    /// - offset: `144`(x86)/`200`(x86_64)
138    /// - type_size: `  4`(x86)/`  4`(x86_64)
139    #[cfg_attr(feature = "json_schema", schemars(rename = "error"))]
140    #[cfg_attr(feature = "serde", serde(rename = "error"))]
141    pub m_error: f32,
142    /// # C++ Info
143    /// - name: `bounds`(ctype: `struct hkAabb`)
144    /// - offset: `160`(x86)/`208`(x86_64)
145    /// - type_size: ` 32`(x86)/` 32`(x86_64)
146    #[cfg_attr(feature = "json_schema", schemars(rename = "bounds"))]
147    #[cfg_attr(feature = "serde", serde(rename = "bounds"))]
148    pub m_bounds: hkAabb,
149    /// # C++ Info
150    /// - name: `defaultCollisionFilterInfo`(ctype: `hkUint32`)
151    /// - offset: `192`(x86)/`240`(x86_64)
152    /// - type_size: `  4`(x86)/`  4`(x86_64)
153    #[cfg_attr(feature = "json_schema", schemars(rename = "defaultCollisionFilterInfo"))]
154    #[cfg_attr(feature = "serde", serde(rename = "defaultCollisionFilterInfo"))]
155    pub m_defaultCollisionFilterInfo: u32,
156    /// # C++ Info
157    /// - name: `meshMaterials`(ctype: `void*`)
158    /// - offset: `196`(x86)/`248`(x86_64)
159    /// - type_size: `  4`(x86)/`  8`(x86_64)
160    /// - flags: `SERIALIZE_IGNORED`
161    #[cfg_attr(feature = "json_schema", schemars(rename = "meshMaterials"))]
162    #[cfg_attr(feature = "serde", serde(rename = "meshMaterials"))]
163    pub m_meshMaterials: Pointer,
164    /// # C++ Info
165    /// - name: `materialStriding`(ctype: `hkUint16`)
166    /// - offset: `200`(x86)/`256`(x86_64)
167    /// - type_size: `  2`(x86)/`  2`(x86_64)
168    #[cfg_attr(feature = "json_schema", schemars(rename = "materialStriding"))]
169    #[cfg_attr(feature = "serde", serde(rename = "materialStriding"))]
170    pub m_materialStriding: u16,
171    /// # C++ Info
172    /// - name: `numMaterials`(ctype: `hkUint16`)
173    /// - offset: `202`(x86)/`258`(x86_64)
174    /// - type_size: `  2`(x86)/`  2`(x86_64)
175    #[cfg_attr(feature = "json_schema", schemars(rename = "numMaterials"))]
176    #[cfg_attr(feature = "serde", serde(rename = "numMaterials"))]
177    pub m_numMaterials: u16,
178    /// # C++ Info
179    /// - name: `namedMaterials`(ctype: `hkArray<struct hkpNamedMeshMaterial>`)
180    /// - offset: `204`(x86)/`264`(x86_64)
181    /// - type_size: ` 12`(x86)/` 16`(x86_64)
182    #[cfg_attr(feature = "serde", serde(borrow))]
183    #[cfg_attr(feature = "json_schema", schemars(rename = "namedMaterials"))]
184    #[cfg_attr(feature = "serde", serde(rename = "namedMaterials"))]
185    pub m_namedMaterials: Vec<hkpNamedMeshMaterial<'a>>,
186}
187const _: () = {
188    use havok_serde as _serde;
189    impl<'a> _serde::HavokClass for hkpCompressedMeshShape<'a> {
190        #[inline]
191        fn name(&self) -> &'static str {
192            "hkpCompressedMeshShape"
193        }
194        #[inline]
195        fn signature(&self) -> _serde::__private::Signature {
196            _serde::__private::Signature::new(0xa62d5e6e)
197        }
198        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
199        fn deps_indexes(&self) -> Vec<usize> {
200            let mut v = Vec::new();
201            v.extend(
202                self
203                    .m_bigTriangles
204                    .iter()
205                    .flat_map(|class| class.deps_indexes())
206                    .collect::<Vec<usize>>(),
207            );
208            v.extend(
209                self
210                    .m_chunks
211                    .iter()
212                    .flat_map(|class| class.deps_indexes())
213                    .collect::<Vec<usize>>(),
214            );
215            v.extend(
216                self
217                    .m_convexPieces
218                    .iter()
219                    .flat_map(|class| class.deps_indexes())
220                    .collect::<Vec<usize>>(),
221            );
222            v.extend(self.m_bounds.deps_indexes());
223            v.push(self.m_meshMaterials.get());
224            v.extend(
225                self
226                    .m_namedMaterials
227                    .iter()
228                    .flat_map(|class| class.deps_indexes())
229                    .collect::<Vec<usize>>(),
230            );
231            v
232        }
233    }
234    impl<'a> _serde::Serialize for hkpCompressedMeshShape<'a> {
235        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
236        where
237            S: _serde::ser::Serializer,
238        {
239            let class_meta = self
240                .__ptr
241                .map(|name| (name, _serde::__private::Signature::new(0xa62d5e6e)));
242            let mut serializer = __serializer
243                .serialize_struct(
244                    "hkpCompressedMeshShape",
245                    class_meta,
246                    (224u64, 304u64),
247                )?;
248            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
249            serializer
250                .skip_field(
251                    "memSizeAndFlags",
252                    &self.parent.parent.parent.m_memSizeAndFlags,
253                )?;
254            serializer
255                .skip_field(
256                    "referenceCount",
257                    &self.parent.parent.parent.m_referenceCount,
258                )?;
259            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
260            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
261            serializer.skip_field("type", &self.parent.parent.m_type)?;
262            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
263            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
264            serializer.serialize_field("disableWelding", &self.parent.m_disableWelding)?;
265            serializer.serialize_field("collectionType", &self.parent.m_collectionType)?;
266            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
267            serializer.serialize_field("bitsPerIndex", &self.m_bitsPerIndex)?;
268            serializer.serialize_field("bitsPerWIndex", &self.m_bitsPerWIndex)?;
269            serializer.serialize_field("wIndexMask", &self.m_wIndexMask)?;
270            serializer.serialize_field("indexMask", &self.m_indexMask)?;
271            serializer.serialize_field("radius", &self.m_radius)?;
272            serializer.serialize_field("weldingType", &self.m_weldingType)?;
273            serializer.serialize_field("materialType", &self.m_materialType)?;
274            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
275            serializer
276                .serialize_array_field(
277                    "materials",
278                    &self.m_materials,
279                    TypeSize::NonPtr,
280                )?;
281            serializer
282                .serialize_array_field(
283                    "materials16",
284                    &self.m_materials16,
285                    TypeSize::NonPtr,
286                )?;
287            serializer
288                .serialize_array_field(
289                    "materials8",
290                    &self.m_materials8,
291                    TypeSize::NonPtr,
292                )?;
293            serializer
294                .serialize_array_field(
295                    "transforms",
296                    &self.m_transforms,
297                    TypeSize::NonPtr,
298                )?;
299            serializer
300                .serialize_array_field(
301                    "bigVertices",
302                    &self.m_bigVertices,
303                    TypeSize::NonPtr,
304                )?;
305            serializer
306                .serialize_array_field(
307                    "bigTriangles",
308                    &self.m_bigTriangles,
309                    TypeSize::Struct {
310                        size_x86: 16u64,
311                        size_x86_64: 16u64,
312                    },
313                )?;
314            serializer
315                .serialize_array_field(
316                    "chunks",
317                    &self.m_chunks,
318                    TypeSize::Struct {
319                        size_x86: 80u64,
320                        size_x86_64: 96u64,
321                    },
322                )?;
323            serializer
324                .serialize_array_field(
325                    "convexPieces",
326                    &self.m_convexPieces,
327                    TypeSize::Struct {
328                        size_x86: 64u64,
329                        size_x86_64: 80u64,
330                    },
331                )?;
332            serializer.serialize_field("error", &self.m_error)?;
333            serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 4usize].as_slice())?;
334            serializer.serialize_field("bounds", &self.m_bounds)?;
335            serializer
336                .serialize_field(
337                    "defaultCollisionFilterInfo",
338                    &self.m_defaultCollisionFilterInfo,
339                )?;
340            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
341            serializer.skip_field("meshMaterials", &self.m_meshMaterials)?;
342            serializer.serialize_field("materialStriding", &self.m_materialStriding)?;
343            serializer.serialize_field("numMaterials", &self.m_numMaterials)?;
344            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
345            serializer
346                .serialize_array_field(
347                    "namedMaterials",
348                    &self.m_namedMaterials,
349                    TypeSize::Struct {
350                        size_x86: 8u64,
351                        size_x86_64: 16u64,
352                    },
353                )?;
354            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 24usize].as_slice())?;
355            serializer.end()
356        }
357    }
358};
359#[doc(hidden)]
360#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
361const _: () = {
362    use havok_serde as _serde;
363    #[automatically_derived]
364    impl<'de> _serde::Deserialize<'de> for hkpCompressedMeshShape<'de> {
365        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
366        where
367            __D: _serde::Deserializer<'de>,
368        {
369            #[allow(non_camel_case_types)]
370            enum __Field {
371                m_userData,
372                m_disableWelding,
373                m_collectionType,
374                m_bitsPerIndex,
375                m_bitsPerWIndex,
376                m_wIndexMask,
377                m_indexMask,
378                m_radius,
379                m_weldingType,
380                m_materialType,
381                m_materials,
382                m_materials16,
383                m_materials8,
384                m_transforms,
385                m_bigVertices,
386                m_bigTriangles,
387                m_chunks,
388                m_convexPieces,
389                m_error,
390                m_bounds,
391                m_defaultCollisionFilterInfo,
392                m_materialStriding,
393                m_numMaterials,
394                m_namedMaterials,
395                __ignore,
396            }
397            struct __FieldVisitor;
398            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
399                type Value = __Field;
400                fn expecting(
401                    &self,
402                    __formatter: &mut core::fmt::Formatter,
403                ) -> core::fmt::Result {
404                    core::fmt::Formatter::write_str(__formatter, "field identifier")
405                }
406                /// Intended for use in XML.
407                #[allow(clippy::match_single_binding)]
408                #[allow(clippy::reversed_empty_ranges)]
409                #[allow(clippy::single_match)]
410                fn visit_key<__E>(
411                    self,
412                    __value: &str,
413                ) -> core::result::Result<Self::Value, __E>
414                where
415                    __E: _serde::de::Error,
416                {
417                    match __value {
418                        "userData" => Ok(__Field::m_userData),
419                        "disableWelding" => Ok(__Field::m_disableWelding),
420                        "collectionType" => Ok(__Field::m_collectionType),
421                        "bitsPerIndex" => Ok(__Field::m_bitsPerIndex),
422                        "bitsPerWIndex" => Ok(__Field::m_bitsPerWIndex),
423                        "wIndexMask" => Ok(__Field::m_wIndexMask),
424                        "indexMask" => Ok(__Field::m_indexMask),
425                        "radius" => Ok(__Field::m_radius),
426                        "weldingType" => Ok(__Field::m_weldingType),
427                        "materialType" => Ok(__Field::m_materialType),
428                        "materials" => Ok(__Field::m_materials),
429                        "materials16" => Ok(__Field::m_materials16),
430                        "materials8" => Ok(__Field::m_materials8),
431                        "transforms" => Ok(__Field::m_transforms),
432                        "bigVertices" => Ok(__Field::m_bigVertices),
433                        "bigTriangles" => Ok(__Field::m_bigTriangles),
434                        "chunks" => Ok(__Field::m_chunks),
435                        "convexPieces" => Ok(__Field::m_convexPieces),
436                        "error" => Ok(__Field::m_error),
437                        "bounds" => Ok(__Field::m_bounds),
438                        "defaultCollisionFilterInfo" => {
439                            Ok(__Field::m_defaultCollisionFilterInfo)
440                        }
441                        "materialStriding" => Ok(__Field::m_materialStriding),
442                        "numMaterials" => Ok(__Field::m_numMaterials),
443                        "namedMaterials" => Ok(__Field::m_namedMaterials),
444                        _ => Ok(__Field::__ignore),
445                    }
446                }
447            }
448            impl<'de> _serde::Deserialize<'de> for __Field {
449                #[inline]
450                fn deserialize<__D>(
451                    __deserializer: __D,
452                ) -> core::result::Result<Self, __D::Error>
453                where
454                    __D: _serde::Deserializer<'de>,
455                {
456                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
457                }
458            }
459            struct __hkpCompressedMeshShapeVisitor<'de> {
460                marker: _serde::__private::PhantomData<hkpCompressedMeshShape<'de>>,
461                lifetime: _serde::__private::PhantomData<&'de ()>,
462            }
463            #[allow(clippy::match_single_binding)]
464            #[allow(clippy::reversed_empty_ranges)]
465            #[allow(clippy::single_match)]
466            impl<'de> _serde::de::Visitor<'de> for __hkpCompressedMeshShapeVisitor<'de> {
467                type Value = hkpCompressedMeshShape<'de>;
468                fn expecting(
469                    &self,
470                    __formatter: &mut core::fmt::Formatter,
471                ) -> core::fmt::Result {
472                    core::fmt::Formatter::write_str(
473                        __formatter,
474                        "struct hkpCompressedMeshShape",
475                    )
476                }
477                fn visit_struct_for_bytes<__A>(
478                    self,
479                    mut __map: __A,
480                ) -> _serde::__private::Result<Self::Value, __A::Error>
481                where
482                    __A: _serde::de::MapAccess<'de>,
483                {
484                    let __ptr = __A::class_ptr(&mut __map);
485                    let parent = __A::parent_value(&mut __map)?;
486                    let mut m_bitsPerIndex: _serde::__private::Option<i32> = _serde::__private::None;
487                    let mut m_bitsPerWIndex: _serde::__private::Option<i32> = _serde::__private::None;
488                    let mut m_wIndexMask: _serde::__private::Option<i32> = _serde::__private::None;
489                    let mut m_indexMask: _serde::__private::Option<i32> = _serde::__private::None;
490                    let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
491                    let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
492                    let mut m_materialType: _serde::__private::Option<MaterialType> = _serde::__private::None;
493                    let mut m_materials: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
494                    let mut m_materials16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
495                    let mut m_materials8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
496                    let mut m_transforms: _serde::__private::Option<Vec<QsTransform>> = _serde::__private::None;
497                    let mut m_bigVertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
498                    let mut m_bigTriangles: _serde::__private::Option<
499                        Vec<hkpCompressedMeshShapeBigTriangle>,
500                    > = _serde::__private::None;
501                    let mut m_chunks: _serde::__private::Option<
502                        Vec<hkpCompressedMeshShapeChunk>,
503                    > = _serde::__private::None;
504                    let mut m_convexPieces: _serde::__private::Option<
505                        Vec<hkpCompressedMeshShapeConvexPiece>,
506                    > = _serde::__private::None;
507                    let mut m_error: _serde::__private::Option<f32> = _serde::__private::None;
508                    let mut m_bounds: _serde::__private::Option<hkAabb> = _serde::__private::None;
509                    let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
510                        u32,
511                    > = _serde::__private::None;
512                    let mut m_meshMaterials: _serde::__private::Option<Pointer> = _serde::__private::None;
513                    let mut m_materialStriding: _serde::__private::Option<u16> = _serde::__private::None;
514                    let mut m_numMaterials: _serde::__private::Option<u16> = _serde::__private::None;
515                    let mut m_namedMaterials: _serde::__private::Option<
516                        Vec<hkpNamedMeshMaterial<'de>>,
517                    > = _serde::__private::None;
518                    for i in 0..22usize {
519                        match i {
520                            0usize => {
521                                if _serde::__private::Option::is_some(&m_bitsPerIndex) {
522                                    return _serde::__private::Err(
523                                        <__A::Error as _serde::de::Error>::duplicate_field(
524                                            "bitsPerIndex",
525                                        ),
526                                    );
527                                }
528                                m_bitsPerIndex = _serde::__private::Some(
529                                    match __A::next_value::<i32>(&mut __map) {
530                                        _serde::__private::Ok(__val) => __val,
531                                        _serde::__private::Err(__err) => {
532                                            return _serde::__private::Err(__err);
533                                        }
534                                    },
535                                );
536                            }
537                            1usize => {
538                                if _serde::__private::Option::is_some(&m_bitsPerWIndex) {
539                                    return _serde::__private::Err(
540                                        <__A::Error as _serde::de::Error>::duplicate_field(
541                                            "bitsPerWIndex",
542                                        ),
543                                    );
544                                }
545                                m_bitsPerWIndex = _serde::__private::Some(
546                                    match __A::next_value::<i32>(&mut __map) {
547                                        _serde::__private::Ok(__val) => __val,
548                                        _serde::__private::Err(__err) => {
549                                            return _serde::__private::Err(__err);
550                                        }
551                                    },
552                                );
553                            }
554                            2usize => {
555                                if _serde::__private::Option::is_some(&m_wIndexMask) {
556                                    return _serde::__private::Err(
557                                        <__A::Error as _serde::de::Error>::duplicate_field(
558                                            "wIndexMask",
559                                        ),
560                                    );
561                                }
562                                m_wIndexMask = _serde::__private::Some(
563                                    match __A::next_value::<i32>(&mut __map) {
564                                        _serde::__private::Ok(__val) => __val,
565                                        _serde::__private::Err(__err) => {
566                                            return _serde::__private::Err(__err);
567                                        }
568                                    },
569                                );
570                            }
571                            3usize => {
572                                if _serde::__private::Option::is_some(&m_indexMask) {
573                                    return _serde::__private::Err(
574                                        <__A::Error as _serde::de::Error>::duplicate_field(
575                                            "indexMask",
576                                        ),
577                                    );
578                                }
579                                m_indexMask = _serde::__private::Some(
580                                    match __A::next_value::<i32>(&mut __map) {
581                                        _serde::__private::Ok(__val) => __val,
582                                        _serde::__private::Err(__err) => {
583                                            return _serde::__private::Err(__err);
584                                        }
585                                    },
586                                );
587                            }
588                            4usize => {
589                                if _serde::__private::Option::is_some(&m_radius) {
590                                    return _serde::__private::Err(
591                                        <__A::Error as _serde::de::Error>::duplicate_field("radius"),
592                                    );
593                                }
594                                m_radius = _serde::__private::Some(
595                                    match __A::next_value::<f32>(&mut __map) {
596                                        _serde::__private::Ok(__val) => __val,
597                                        _serde::__private::Err(__err) => {
598                                            return _serde::__private::Err(__err);
599                                        }
600                                    },
601                                );
602                            }
603                            5usize => {
604                                if _serde::__private::Option::is_some(&m_weldingType) {
605                                    return _serde::__private::Err(
606                                        <__A::Error as _serde::de::Error>::duplicate_field(
607                                            "weldingType",
608                                        ),
609                                    );
610                                }
611                                m_weldingType = _serde::__private::Some(
612                                    match __A::next_value::<WeldingType>(&mut __map) {
613                                        _serde::__private::Ok(__val) => __val,
614                                        _serde::__private::Err(__err) => {
615                                            return _serde::__private::Err(__err);
616                                        }
617                                    },
618                                );
619                            }
620                            6usize => {
621                                if _serde::__private::Option::is_some(&m_materialType) {
622                                    return _serde::__private::Err(
623                                        <__A::Error as _serde::de::Error>::duplicate_field(
624                                            "materialType",
625                                        ),
626                                    );
627                                }
628                                m_materialType = _serde::__private::Some(
629                                    match __A::next_value::<MaterialType>(&mut __map) {
630                                        _serde::__private::Ok(__val) => __val,
631                                        _serde::__private::Err(__err) => {
632                                            return _serde::__private::Err(__err);
633                                        }
634                                    },
635                                );
636                            }
637                            7usize => {
638                                if _serde::__private::Option::is_some(&m_materials) {
639                                    return _serde::__private::Err(
640                                        <__A::Error as _serde::de::Error>::duplicate_field(
641                                            "materials",
642                                        ),
643                                    );
644                                }
645                                __A::pad(&mut __map, 2usize, 2usize)?;
646                                m_materials = _serde::__private::Some(
647                                    match __A::next_value::<Vec<u32>>(&mut __map) {
648                                        _serde::__private::Ok(__val) => __val,
649                                        _serde::__private::Err(__err) => {
650                                            return _serde::__private::Err(__err);
651                                        }
652                                    },
653                                );
654                            }
655                            8usize => {
656                                if _serde::__private::Option::is_some(&m_materials16) {
657                                    return _serde::__private::Err(
658                                        <__A::Error as _serde::de::Error>::duplicate_field(
659                                            "materials16",
660                                        ),
661                                    );
662                                }
663                                m_materials16 = _serde::__private::Some(
664                                    match __A::next_value::<Vec<u16>>(&mut __map) {
665                                        _serde::__private::Ok(__val) => __val,
666                                        _serde::__private::Err(__err) => {
667                                            return _serde::__private::Err(__err);
668                                        }
669                                    },
670                                );
671                            }
672                            9usize => {
673                                if _serde::__private::Option::is_some(&m_materials8) {
674                                    return _serde::__private::Err(
675                                        <__A::Error as _serde::de::Error>::duplicate_field(
676                                            "materials8",
677                                        ),
678                                    );
679                                }
680                                m_materials8 = _serde::__private::Some(
681                                    match __A::next_value::<Vec<u8>>(&mut __map) {
682                                        _serde::__private::Ok(__val) => __val,
683                                        _serde::__private::Err(__err) => {
684                                            return _serde::__private::Err(__err);
685                                        }
686                                    },
687                                );
688                            }
689                            10usize => {
690                                if _serde::__private::Option::is_some(&m_transforms) {
691                                    return _serde::__private::Err(
692                                        <__A::Error as _serde::de::Error>::duplicate_field(
693                                            "transforms",
694                                        ),
695                                    );
696                                }
697                                m_transforms = _serde::__private::Some(
698                                    match __A::next_value::<Vec<QsTransform>>(&mut __map) {
699                                        _serde::__private::Ok(__val) => __val,
700                                        _serde::__private::Err(__err) => {
701                                            return _serde::__private::Err(__err);
702                                        }
703                                    },
704                                );
705                            }
706                            11usize => {
707                                if _serde::__private::Option::is_some(&m_bigVertices) {
708                                    return _serde::__private::Err(
709                                        <__A::Error as _serde::de::Error>::duplicate_field(
710                                            "bigVertices",
711                                        ),
712                                    );
713                                }
714                                m_bigVertices = _serde::__private::Some(
715                                    match __A::next_value::<Vec<Vector4>>(&mut __map) {
716                                        _serde::__private::Ok(__val) => __val,
717                                        _serde::__private::Err(__err) => {
718                                            return _serde::__private::Err(__err);
719                                        }
720                                    },
721                                );
722                            }
723                            12usize => {
724                                if _serde::__private::Option::is_some(&m_bigTriangles) {
725                                    return _serde::__private::Err(
726                                        <__A::Error as _serde::de::Error>::duplicate_field(
727                                            "bigTriangles",
728                                        ),
729                                    );
730                                }
731                                m_bigTriangles = _serde::__private::Some(
732                                    match __A::next_value::<
733                                        Vec<hkpCompressedMeshShapeBigTriangle>,
734                                    >(&mut __map) {
735                                        _serde::__private::Ok(__val) => __val,
736                                        _serde::__private::Err(__err) => {
737                                            return _serde::__private::Err(__err);
738                                        }
739                                    },
740                                );
741                            }
742                            13usize => {
743                                if _serde::__private::Option::is_some(&m_chunks) {
744                                    return _serde::__private::Err(
745                                        <__A::Error as _serde::de::Error>::duplicate_field("chunks"),
746                                    );
747                                }
748                                m_chunks = _serde::__private::Some(
749                                    match __A::next_value::<
750                                        Vec<hkpCompressedMeshShapeChunk>,
751                                    >(&mut __map) {
752                                        _serde::__private::Ok(__val) => __val,
753                                        _serde::__private::Err(__err) => {
754                                            return _serde::__private::Err(__err);
755                                        }
756                                    },
757                                );
758                            }
759                            14usize => {
760                                if _serde::__private::Option::is_some(&m_convexPieces) {
761                                    return _serde::__private::Err(
762                                        <__A::Error as _serde::de::Error>::duplicate_field(
763                                            "convexPieces",
764                                        ),
765                                    );
766                                }
767                                m_convexPieces = _serde::__private::Some(
768                                    match __A::next_value::<
769                                        Vec<hkpCompressedMeshShapeConvexPiece>,
770                                    >(&mut __map) {
771                                        _serde::__private::Ok(__val) => __val,
772                                        _serde::__private::Err(__err) => {
773                                            return _serde::__private::Err(__err);
774                                        }
775                                    },
776                                );
777                            }
778                            15usize => {
779                                if _serde::__private::Option::is_some(&m_error) {
780                                    return _serde::__private::Err(
781                                        <__A::Error as _serde::de::Error>::duplicate_field("error"),
782                                    );
783                                }
784                                m_error = _serde::__private::Some(
785                                    match __A::next_value::<f32>(&mut __map) {
786                                        _serde::__private::Ok(__val) => __val,
787                                        _serde::__private::Err(__err) => {
788                                            return _serde::__private::Err(__err);
789                                        }
790                                    },
791                                );
792                            }
793                            16usize => {
794                                if _serde::__private::Option::is_some(&m_bounds) {
795                                    return _serde::__private::Err(
796                                        <__A::Error as _serde::de::Error>::duplicate_field("bounds"),
797                                    );
798                                }
799                                __A::pad(&mut __map, 12usize, 4usize)?;
800                                m_bounds = _serde::__private::Some(
801                                    match __A::next_value::<hkAabb>(&mut __map) {
802                                        _serde::__private::Ok(__val) => __val,
803                                        _serde::__private::Err(__err) => {
804                                            return _serde::__private::Err(__err);
805                                        }
806                                    },
807                                );
808                            }
809                            17usize => {
810                                if _serde::__private::Option::is_some(
811                                    &m_defaultCollisionFilterInfo,
812                                ) {
813                                    return _serde::__private::Err(
814                                        <__A::Error as _serde::de::Error>::duplicate_field(
815                                            "defaultCollisionFilterInfo",
816                                        ),
817                                    );
818                                }
819                                m_defaultCollisionFilterInfo = _serde::__private::Some(
820                                    match __A::next_value::<u32>(&mut __map) {
821                                        _serde::__private::Ok(__val) => __val,
822                                        _serde::__private::Err(__err) => {
823                                            return _serde::__private::Err(__err);
824                                        }
825                                    },
826                                );
827                            }
828                            18usize => {
829                                if _serde::__private::Option::is_some(&m_meshMaterials) {
830                                    return _serde::__private::Err(
831                                        <__A::Error as _serde::de::Error>::duplicate_field(
832                                            "meshMaterials",
833                                        ),
834                                    );
835                                }
836                                __A::pad(&mut __map, 0usize, 4usize)?;
837                                m_meshMaterials = _serde::__private::Some(
838                                    match __A::next_value::<Pointer>(&mut __map) {
839                                        _serde::__private::Ok(__val) => __val,
840                                        _serde::__private::Err(__err) => {
841                                            return _serde::__private::Err(__err);
842                                        }
843                                    },
844                                );
845                            }
846                            19usize => {
847                                if _serde::__private::Option::is_some(&m_materialStriding) {
848                                    return _serde::__private::Err(
849                                        <__A::Error as _serde::de::Error>::duplicate_field(
850                                            "materialStriding",
851                                        ),
852                                    );
853                                }
854                                m_materialStriding = _serde::__private::Some(
855                                    match __A::next_value::<u16>(&mut __map) {
856                                        _serde::__private::Ok(__val) => __val,
857                                        _serde::__private::Err(__err) => {
858                                            return _serde::__private::Err(__err);
859                                        }
860                                    },
861                                );
862                            }
863                            20usize => {
864                                if _serde::__private::Option::is_some(&m_numMaterials) {
865                                    return _serde::__private::Err(
866                                        <__A::Error as _serde::de::Error>::duplicate_field(
867                                            "numMaterials",
868                                        ),
869                                    );
870                                }
871                                m_numMaterials = _serde::__private::Some(
872                                    match __A::next_value::<u16>(&mut __map) {
873                                        _serde::__private::Ok(__val) => __val,
874                                        _serde::__private::Err(__err) => {
875                                            return _serde::__private::Err(__err);
876                                        }
877                                    },
878                                );
879                            }
880                            21usize => {
881                                if _serde::__private::Option::is_some(&m_namedMaterials) {
882                                    return _serde::__private::Err(
883                                        <__A::Error as _serde::de::Error>::duplicate_field(
884                                            "namedMaterials",
885                                        ),
886                                    );
887                                }
888                                __A::pad(&mut __map, 0usize, 4usize)?;
889                                m_namedMaterials = _serde::__private::Some(
890                                    match __A::next_value::<
891                                        Vec<hkpNamedMeshMaterial<'de>>,
892                                    >(&mut __map) {
893                                        _serde::__private::Ok(__val) => __val,
894                                        _serde::__private::Err(__err) => {
895                                            return _serde::__private::Err(__err);
896                                        }
897                                    },
898                                );
899                            }
900                            _ => {}
901                        }
902                    }
903                    __A::pad(&mut __map, 8usize, 24usize)?;
904                    let m_bitsPerIndex = match m_bitsPerIndex {
905                        _serde::__private::Some(__field) => __field,
906                        _serde::__private::None => {
907                            return _serde::__private::Err(
908                                <__A::Error as _serde::de::Error>::missing_field(
909                                    "bitsPerIndex",
910                                ),
911                            );
912                        }
913                    };
914                    let m_bitsPerWIndex = match m_bitsPerWIndex {
915                        _serde::__private::Some(__field) => __field,
916                        _serde::__private::None => {
917                            return _serde::__private::Err(
918                                <__A::Error as _serde::de::Error>::missing_field(
919                                    "bitsPerWIndex",
920                                ),
921                            );
922                        }
923                    };
924                    let m_wIndexMask = match m_wIndexMask {
925                        _serde::__private::Some(__field) => __field,
926                        _serde::__private::None => {
927                            return _serde::__private::Err(
928                                <__A::Error as _serde::de::Error>::missing_field(
929                                    "wIndexMask",
930                                ),
931                            );
932                        }
933                    };
934                    let m_indexMask = match m_indexMask {
935                        _serde::__private::Some(__field) => __field,
936                        _serde::__private::None => {
937                            return _serde::__private::Err(
938                                <__A::Error as _serde::de::Error>::missing_field(
939                                    "indexMask",
940                                ),
941                            );
942                        }
943                    };
944                    let m_radius = match m_radius {
945                        _serde::__private::Some(__field) => __field,
946                        _serde::__private::None => {
947                            return _serde::__private::Err(
948                                <__A::Error as _serde::de::Error>::missing_field("radius"),
949                            );
950                        }
951                    };
952                    let m_weldingType = match m_weldingType {
953                        _serde::__private::Some(__field) => __field,
954                        _serde::__private::None => {
955                            return _serde::__private::Err(
956                                <__A::Error as _serde::de::Error>::missing_field(
957                                    "weldingType",
958                                ),
959                            );
960                        }
961                    };
962                    let m_materialType = match m_materialType {
963                        _serde::__private::Some(__field) => __field,
964                        _serde::__private::None => {
965                            return _serde::__private::Err(
966                                <__A::Error as _serde::de::Error>::missing_field(
967                                    "materialType",
968                                ),
969                            );
970                        }
971                    };
972                    let m_materials = match m_materials {
973                        _serde::__private::Some(__field) => __field,
974                        _serde::__private::None => {
975                            return _serde::__private::Err(
976                                <__A::Error as _serde::de::Error>::missing_field(
977                                    "materials",
978                                ),
979                            );
980                        }
981                    };
982                    let m_materials16 = match m_materials16 {
983                        _serde::__private::Some(__field) => __field,
984                        _serde::__private::None => {
985                            return _serde::__private::Err(
986                                <__A::Error as _serde::de::Error>::missing_field(
987                                    "materials16",
988                                ),
989                            );
990                        }
991                    };
992                    let m_materials8 = match m_materials8 {
993                        _serde::__private::Some(__field) => __field,
994                        _serde::__private::None => {
995                            return _serde::__private::Err(
996                                <__A::Error as _serde::de::Error>::missing_field(
997                                    "materials8",
998                                ),
999                            );
1000                        }
1001                    };
1002                    let m_transforms = match m_transforms {
1003                        _serde::__private::Some(__field) => __field,
1004                        _serde::__private::None => {
1005                            return _serde::__private::Err(
1006                                <__A::Error as _serde::de::Error>::missing_field(
1007                                    "transforms",
1008                                ),
1009                            );
1010                        }
1011                    };
1012                    let m_bigVertices = match m_bigVertices {
1013                        _serde::__private::Some(__field) => __field,
1014                        _serde::__private::None => {
1015                            return _serde::__private::Err(
1016                                <__A::Error as _serde::de::Error>::missing_field(
1017                                    "bigVertices",
1018                                ),
1019                            );
1020                        }
1021                    };
1022                    let m_bigTriangles = match m_bigTriangles {
1023                        _serde::__private::Some(__field) => __field,
1024                        _serde::__private::None => {
1025                            return _serde::__private::Err(
1026                                <__A::Error as _serde::de::Error>::missing_field(
1027                                    "bigTriangles",
1028                                ),
1029                            );
1030                        }
1031                    };
1032                    let m_chunks = match m_chunks {
1033                        _serde::__private::Some(__field) => __field,
1034                        _serde::__private::None => {
1035                            return _serde::__private::Err(
1036                                <__A::Error as _serde::de::Error>::missing_field("chunks"),
1037                            );
1038                        }
1039                    };
1040                    let m_convexPieces = match m_convexPieces {
1041                        _serde::__private::Some(__field) => __field,
1042                        _serde::__private::None => {
1043                            return _serde::__private::Err(
1044                                <__A::Error as _serde::de::Error>::missing_field(
1045                                    "convexPieces",
1046                                ),
1047                            );
1048                        }
1049                    };
1050                    let m_error = match m_error {
1051                        _serde::__private::Some(__field) => __field,
1052                        _serde::__private::None => {
1053                            return _serde::__private::Err(
1054                                <__A::Error as _serde::de::Error>::missing_field("error"),
1055                            );
1056                        }
1057                    };
1058                    let m_bounds = match m_bounds {
1059                        _serde::__private::Some(__field) => __field,
1060                        _serde::__private::None => {
1061                            return _serde::__private::Err(
1062                                <__A::Error as _serde::de::Error>::missing_field("bounds"),
1063                            );
1064                        }
1065                    };
1066                    let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
1067                        _serde::__private::Some(__field) => __field,
1068                        _serde::__private::None => {
1069                            return _serde::__private::Err(
1070                                <__A::Error as _serde::de::Error>::missing_field(
1071                                    "defaultCollisionFilterInfo",
1072                                ),
1073                            );
1074                        }
1075                    };
1076                    let m_meshMaterials = match m_meshMaterials {
1077                        _serde::__private::Some(__field) => __field,
1078                        _serde::__private::None => {
1079                            return _serde::__private::Err(
1080                                <__A::Error as _serde::de::Error>::missing_field(
1081                                    "meshMaterials",
1082                                ),
1083                            );
1084                        }
1085                    };
1086                    let m_materialStriding = match m_materialStriding {
1087                        _serde::__private::Some(__field) => __field,
1088                        _serde::__private::None => {
1089                            return _serde::__private::Err(
1090                                <__A::Error as _serde::de::Error>::missing_field(
1091                                    "materialStriding",
1092                                ),
1093                            );
1094                        }
1095                    };
1096                    let m_numMaterials = match m_numMaterials {
1097                        _serde::__private::Some(__field) => __field,
1098                        _serde::__private::None => {
1099                            return _serde::__private::Err(
1100                                <__A::Error as _serde::de::Error>::missing_field(
1101                                    "numMaterials",
1102                                ),
1103                            );
1104                        }
1105                    };
1106                    let m_namedMaterials = match m_namedMaterials {
1107                        _serde::__private::Some(__field) => __field,
1108                        _serde::__private::None => {
1109                            return _serde::__private::Err(
1110                                <__A::Error as _serde::de::Error>::missing_field(
1111                                    "namedMaterials",
1112                                ),
1113                            );
1114                        }
1115                    };
1116                    _serde::__private::Ok(hkpCompressedMeshShape {
1117                        __ptr,
1118                        parent,
1119                        m_bitsPerIndex,
1120                        m_bitsPerWIndex,
1121                        m_wIndexMask,
1122                        m_indexMask,
1123                        m_radius,
1124                        m_weldingType,
1125                        m_materialType,
1126                        m_materials,
1127                        m_materials16,
1128                        m_materials8,
1129                        m_transforms,
1130                        m_bigVertices,
1131                        m_bigTriangles,
1132                        m_chunks,
1133                        m_convexPieces,
1134                        m_error,
1135                        m_bounds,
1136                        m_defaultCollisionFilterInfo,
1137                        m_meshMaterials,
1138                        m_materialStriding,
1139                        m_numMaterials,
1140                        m_namedMaterials,
1141                    })
1142                }
1143                #[allow(clippy::manual_unwrap_or_default)]
1144                fn visit_struct<__A>(
1145                    self,
1146                    mut __map: __A,
1147                ) -> _serde::__private::Result<Self::Value, __A::Error>
1148                where
1149                    __A: _serde::de::MapAccess<'de>,
1150                {
1151                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1152                    let mut m_disableWelding: _serde::__private::Option<bool> = _serde::__private::None;
1153                    let mut m_collectionType: _serde::__private::Option<
1154                        CollectionType,
1155                    > = _serde::__private::None;
1156                    let mut m_bitsPerIndex: _serde::__private::Option<i32> = _serde::__private::None;
1157                    let mut m_bitsPerWIndex: _serde::__private::Option<i32> = _serde::__private::None;
1158                    let mut m_wIndexMask: _serde::__private::Option<i32> = _serde::__private::None;
1159                    let mut m_indexMask: _serde::__private::Option<i32> = _serde::__private::None;
1160                    let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
1161                    let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
1162                    let mut m_materialType: _serde::__private::Option<MaterialType> = _serde::__private::None;
1163                    let mut m_materials: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
1164                    let mut m_materials16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
1165                    let mut m_materials8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
1166                    let mut m_transforms: _serde::__private::Option<Vec<QsTransform>> = _serde::__private::None;
1167                    let mut m_bigVertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
1168                    let mut m_bigTriangles: _serde::__private::Option<
1169                        Vec<hkpCompressedMeshShapeBigTriangle>,
1170                    > = _serde::__private::None;
1171                    let mut m_chunks: _serde::__private::Option<
1172                        Vec<hkpCompressedMeshShapeChunk>,
1173                    > = _serde::__private::None;
1174                    let mut m_convexPieces: _serde::__private::Option<
1175                        Vec<hkpCompressedMeshShapeConvexPiece>,
1176                    > = _serde::__private::None;
1177                    let mut m_error: _serde::__private::Option<f32> = _serde::__private::None;
1178                    let mut m_bounds: _serde::__private::Option<hkAabb> = _serde::__private::None;
1179                    let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
1180                        u32,
1181                    > = _serde::__private::None;
1182                    let mut m_materialStriding: _serde::__private::Option<u16> = _serde::__private::None;
1183                    let mut m_numMaterials: _serde::__private::Option<u16> = _serde::__private::None;
1184                    let mut m_namedMaterials: _serde::__private::Option<
1185                        Vec<hkpNamedMeshMaterial<'de>>,
1186                    > = _serde::__private::None;
1187                    while let _serde::__private::Some(__key) = {
1188                        __A::next_key::<__Field>(&mut __map)?
1189                    } {
1190                        match __key {
1191                            __Field::m_userData => {
1192                                #[cfg(
1193                                    any(feature = "strict", feature = "ignore_duplicates")
1194                                )]
1195                                if _serde::__private::Option::is_some(&m_userData) {
1196                                    #[cfg(feature = "ignore_duplicates")]
1197                                    {
1198                                        __A::skip_value(&mut __map)?;
1199                                        continue;
1200                                    }
1201                                    #[cfg(feature = "strict")]
1202                                    return _serde::__private::Err(
1203                                        <__A::Error as _serde::de::Error>::duplicate_field(
1204                                            "userData",
1205                                        ),
1206                                    );
1207                                }
1208                                m_userData = _serde::__private::Some(
1209                                    match __A::next_value::<Ulong>(&mut __map) {
1210                                        _serde::__private::Ok(__val) => __val,
1211                                        _serde::__private::Err(__err) => {
1212                                            return _serde::__private::Err(__err);
1213                                        }
1214                                    },
1215                                );
1216                            }
1217                            __Field::m_disableWelding => {
1218                                #[cfg(
1219                                    any(feature = "strict", feature = "ignore_duplicates")
1220                                )]
1221                                if _serde::__private::Option::is_some(&m_disableWelding) {
1222                                    #[cfg(feature = "ignore_duplicates")]
1223                                    {
1224                                        __A::skip_value(&mut __map)?;
1225                                        continue;
1226                                    }
1227                                    #[cfg(feature = "strict")]
1228                                    return _serde::__private::Err(
1229                                        <__A::Error as _serde::de::Error>::duplicate_field(
1230                                            "disableWelding",
1231                                        ),
1232                                    );
1233                                }
1234                                m_disableWelding = _serde::__private::Some(
1235                                    match __A::next_value::<bool>(&mut __map) {
1236                                        _serde::__private::Ok(__val) => __val,
1237                                        _serde::__private::Err(__err) => {
1238                                            return _serde::__private::Err(__err);
1239                                        }
1240                                    },
1241                                );
1242                            }
1243                            __Field::m_collectionType => {
1244                                #[cfg(
1245                                    any(feature = "strict", feature = "ignore_duplicates")
1246                                )]
1247                                if _serde::__private::Option::is_some(&m_collectionType) {
1248                                    #[cfg(feature = "ignore_duplicates")]
1249                                    {
1250                                        __A::skip_value(&mut __map)?;
1251                                        continue;
1252                                    }
1253                                    #[cfg(feature = "strict")]
1254                                    return _serde::__private::Err(
1255                                        <__A::Error as _serde::de::Error>::duplicate_field(
1256                                            "collectionType",
1257                                        ),
1258                                    );
1259                                }
1260                                m_collectionType = _serde::__private::Some(
1261                                    match __A::next_value::<CollectionType>(&mut __map) {
1262                                        _serde::__private::Ok(__val) => __val,
1263                                        _serde::__private::Err(__err) => {
1264                                            return _serde::__private::Err(__err);
1265                                        }
1266                                    },
1267                                );
1268                            }
1269                            __Field::m_bitsPerIndex => {
1270                                #[cfg(
1271                                    any(feature = "strict", feature = "ignore_duplicates")
1272                                )]
1273                                if _serde::__private::Option::is_some(&m_bitsPerIndex) {
1274                                    #[cfg(feature = "ignore_duplicates")]
1275                                    {
1276                                        __A::skip_value(&mut __map)?;
1277                                        continue;
1278                                    }
1279                                    #[cfg(feature = "strict")]
1280                                    return _serde::__private::Err(
1281                                        <__A::Error as _serde::de::Error>::duplicate_field(
1282                                            "bitsPerIndex",
1283                                        ),
1284                                    );
1285                                }
1286                                m_bitsPerIndex = _serde::__private::Some(
1287                                    match __A::next_value::<i32>(&mut __map) {
1288                                        _serde::__private::Ok(__val) => __val,
1289                                        _serde::__private::Err(__err) => {
1290                                            return _serde::__private::Err(__err);
1291                                        }
1292                                    },
1293                                );
1294                            }
1295                            __Field::m_bitsPerWIndex => {
1296                                #[cfg(
1297                                    any(feature = "strict", feature = "ignore_duplicates")
1298                                )]
1299                                if _serde::__private::Option::is_some(&m_bitsPerWIndex) {
1300                                    #[cfg(feature = "ignore_duplicates")]
1301                                    {
1302                                        __A::skip_value(&mut __map)?;
1303                                        continue;
1304                                    }
1305                                    #[cfg(feature = "strict")]
1306                                    return _serde::__private::Err(
1307                                        <__A::Error as _serde::de::Error>::duplicate_field(
1308                                            "bitsPerWIndex",
1309                                        ),
1310                                    );
1311                                }
1312                                m_bitsPerWIndex = _serde::__private::Some(
1313                                    match __A::next_value::<i32>(&mut __map) {
1314                                        _serde::__private::Ok(__val) => __val,
1315                                        _serde::__private::Err(__err) => {
1316                                            return _serde::__private::Err(__err);
1317                                        }
1318                                    },
1319                                );
1320                            }
1321                            __Field::m_wIndexMask => {
1322                                #[cfg(
1323                                    any(feature = "strict", feature = "ignore_duplicates")
1324                                )]
1325                                if _serde::__private::Option::is_some(&m_wIndexMask) {
1326                                    #[cfg(feature = "ignore_duplicates")]
1327                                    {
1328                                        __A::skip_value(&mut __map)?;
1329                                        continue;
1330                                    }
1331                                    #[cfg(feature = "strict")]
1332                                    return _serde::__private::Err(
1333                                        <__A::Error as _serde::de::Error>::duplicate_field(
1334                                            "wIndexMask",
1335                                        ),
1336                                    );
1337                                }
1338                                m_wIndexMask = _serde::__private::Some(
1339                                    match __A::next_value::<i32>(&mut __map) {
1340                                        _serde::__private::Ok(__val) => __val,
1341                                        _serde::__private::Err(__err) => {
1342                                            return _serde::__private::Err(__err);
1343                                        }
1344                                    },
1345                                );
1346                            }
1347                            __Field::m_indexMask => {
1348                                #[cfg(
1349                                    any(feature = "strict", feature = "ignore_duplicates")
1350                                )]
1351                                if _serde::__private::Option::is_some(&m_indexMask) {
1352                                    #[cfg(feature = "ignore_duplicates")]
1353                                    {
1354                                        __A::skip_value(&mut __map)?;
1355                                        continue;
1356                                    }
1357                                    #[cfg(feature = "strict")]
1358                                    return _serde::__private::Err(
1359                                        <__A::Error as _serde::de::Error>::duplicate_field(
1360                                            "indexMask",
1361                                        ),
1362                                    );
1363                                }
1364                                m_indexMask = _serde::__private::Some(
1365                                    match __A::next_value::<i32>(&mut __map) {
1366                                        _serde::__private::Ok(__val) => __val,
1367                                        _serde::__private::Err(__err) => {
1368                                            return _serde::__private::Err(__err);
1369                                        }
1370                                    },
1371                                );
1372                            }
1373                            __Field::m_radius => {
1374                                #[cfg(
1375                                    any(feature = "strict", feature = "ignore_duplicates")
1376                                )]
1377                                if _serde::__private::Option::is_some(&m_radius) {
1378                                    #[cfg(feature = "ignore_duplicates")]
1379                                    {
1380                                        __A::skip_value(&mut __map)?;
1381                                        continue;
1382                                    }
1383                                    #[cfg(feature = "strict")]
1384                                    return _serde::__private::Err(
1385                                        <__A::Error as _serde::de::Error>::duplicate_field("radius"),
1386                                    );
1387                                }
1388                                m_radius = _serde::__private::Some(
1389                                    match __A::next_value::<f32>(&mut __map) {
1390                                        _serde::__private::Ok(__val) => __val,
1391                                        _serde::__private::Err(__err) => {
1392                                            return _serde::__private::Err(__err);
1393                                        }
1394                                    },
1395                                );
1396                            }
1397                            __Field::m_weldingType => {
1398                                #[cfg(
1399                                    any(feature = "strict", feature = "ignore_duplicates")
1400                                )]
1401                                if _serde::__private::Option::is_some(&m_weldingType) {
1402                                    #[cfg(feature = "ignore_duplicates")]
1403                                    {
1404                                        __A::skip_value(&mut __map)?;
1405                                        continue;
1406                                    }
1407                                    #[cfg(feature = "strict")]
1408                                    return _serde::__private::Err(
1409                                        <__A::Error as _serde::de::Error>::duplicate_field(
1410                                            "weldingType",
1411                                        ),
1412                                    );
1413                                }
1414                                m_weldingType = _serde::__private::Some(
1415                                    match __A::next_value::<WeldingType>(&mut __map) {
1416                                        _serde::__private::Ok(__val) => __val,
1417                                        _serde::__private::Err(__err) => {
1418                                            return _serde::__private::Err(__err);
1419                                        }
1420                                    },
1421                                );
1422                            }
1423                            __Field::m_materialType => {
1424                                #[cfg(
1425                                    any(feature = "strict", feature = "ignore_duplicates")
1426                                )]
1427                                if _serde::__private::Option::is_some(&m_materialType) {
1428                                    #[cfg(feature = "ignore_duplicates")]
1429                                    {
1430                                        __A::skip_value(&mut __map)?;
1431                                        continue;
1432                                    }
1433                                    #[cfg(feature = "strict")]
1434                                    return _serde::__private::Err(
1435                                        <__A::Error as _serde::de::Error>::duplicate_field(
1436                                            "materialType",
1437                                        ),
1438                                    );
1439                                }
1440                                m_materialType = _serde::__private::Some(
1441                                    match __A::next_value::<MaterialType>(&mut __map) {
1442                                        _serde::__private::Ok(__val) => __val,
1443                                        _serde::__private::Err(__err) => {
1444                                            return _serde::__private::Err(__err);
1445                                        }
1446                                    },
1447                                );
1448                            }
1449                            __Field::m_materials => {
1450                                #[cfg(
1451                                    any(feature = "strict", feature = "ignore_duplicates")
1452                                )]
1453                                if _serde::__private::Option::is_some(&m_materials) {
1454                                    #[cfg(feature = "ignore_duplicates")]
1455                                    {
1456                                        __A::skip_value(&mut __map)?;
1457                                        continue;
1458                                    }
1459                                    #[cfg(feature = "strict")]
1460                                    return _serde::__private::Err(
1461                                        <__A::Error as _serde::de::Error>::duplicate_field(
1462                                            "materials",
1463                                        ),
1464                                    );
1465                                }
1466                                m_materials = _serde::__private::Some(
1467                                    match __A::next_value::<Vec<u32>>(&mut __map) {
1468                                        _serde::__private::Ok(__val) => __val,
1469                                        _serde::__private::Err(__err) => {
1470                                            return _serde::__private::Err(__err);
1471                                        }
1472                                    },
1473                                );
1474                            }
1475                            __Field::m_materials16 => {
1476                                #[cfg(
1477                                    any(feature = "strict", feature = "ignore_duplicates")
1478                                )]
1479                                if _serde::__private::Option::is_some(&m_materials16) {
1480                                    #[cfg(feature = "ignore_duplicates")]
1481                                    {
1482                                        __A::skip_value(&mut __map)?;
1483                                        continue;
1484                                    }
1485                                    #[cfg(feature = "strict")]
1486                                    return _serde::__private::Err(
1487                                        <__A::Error as _serde::de::Error>::duplicate_field(
1488                                            "materials16",
1489                                        ),
1490                                    );
1491                                }
1492                                m_materials16 = _serde::__private::Some(
1493                                    match __A::next_value::<Vec<u16>>(&mut __map) {
1494                                        _serde::__private::Ok(__val) => __val,
1495                                        _serde::__private::Err(__err) => {
1496                                            return _serde::__private::Err(__err);
1497                                        }
1498                                    },
1499                                );
1500                            }
1501                            __Field::m_materials8 => {
1502                                #[cfg(
1503                                    any(feature = "strict", feature = "ignore_duplicates")
1504                                )]
1505                                if _serde::__private::Option::is_some(&m_materials8) {
1506                                    #[cfg(feature = "ignore_duplicates")]
1507                                    {
1508                                        __A::skip_value(&mut __map)?;
1509                                        continue;
1510                                    }
1511                                    #[cfg(feature = "strict")]
1512                                    return _serde::__private::Err(
1513                                        <__A::Error as _serde::de::Error>::duplicate_field(
1514                                            "materials8",
1515                                        ),
1516                                    );
1517                                }
1518                                m_materials8 = _serde::__private::Some(
1519                                    match __A::next_value::<Vec<u8>>(&mut __map) {
1520                                        _serde::__private::Ok(__val) => __val,
1521                                        _serde::__private::Err(__err) => {
1522                                            return _serde::__private::Err(__err);
1523                                        }
1524                                    },
1525                                );
1526                            }
1527                            __Field::m_transforms => {
1528                                #[cfg(
1529                                    any(feature = "strict", feature = "ignore_duplicates")
1530                                )]
1531                                if _serde::__private::Option::is_some(&m_transforms) {
1532                                    #[cfg(feature = "ignore_duplicates")]
1533                                    {
1534                                        __A::skip_value(&mut __map)?;
1535                                        continue;
1536                                    }
1537                                    #[cfg(feature = "strict")]
1538                                    return _serde::__private::Err(
1539                                        <__A::Error as _serde::de::Error>::duplicate_field(
1540                                            "transforms",
1541                                        ),
1542                                    );
1543                                }
1544                                m_transforms = _serde::__private::Some(
1545                                    match __A::next_value::<Vec<QsTransform>>(&mut __map) {
1546                                        _serde::__private::Ok(__val) => __val,
1547                                        _serde::__private::Err(__err) => {
1548                                            return _serde::__private::Err(__err);
1549                                        }
1550                                    },
1551                                );
1552                            }
1553                            __Field::m_bigVertices => {
1554                                #[cfg(
1555                                    any(feature = "strict", feature = "ignore_duplicates")
1556                                )]
1557                                if _serde::__private::Option::is_some(&m_bigVertices) {
1558                                    #[cfg(feature = "ignore_duplicates")]
1559                                    {
1560                                        __A::skip_value(&mut __map)?;
1561                                        continue;
1562                                    }
1563                                    #[cfg(feature = "strict")]
1564                                    return _serde::__private::Err(
1565                                        <__A::Error as _serde::de::Error>::duplicate_field(
1566                                            "bigVertices",
1567                                        ),
1568                                    );
1569                                }
1570                                m_bigVertices = _serde::__private::Some(
1571                                    match __A::next_value::<Vec<Vector4>>(&mut __map) {
1572                                        _serde::__private::Ok(__val) => __val,
1573                                        _serde::__private::Err(__err) => {
1574                                            return _serde::__private::Err(__err);
1575                                        }
1576                                    },
1577                                );
1578                            }
1579                            __Field::m_bigTriangles => {
1580                                #[cfg(
1581                                    any(feature = "strict", feature = "ignore_duplicates")
1582                                )]
1583                                if _serde::__private::Option::is_some(&m_bigTriangles) {
1584                                    #[cfg(feature = "ignore_duplicates")]
1585                                    {
1586                                        __A::skip_value(&mut __map)?;
1587                                        continue;
1588                                    }
1589                                    #[cfg(feature = "strict")]
1590                                    return _serde::__private::Err(
1591                                        <__A::Error as _serde::de::Error>::duplicate_field(
1592                                            "bigTriangles",
1593                                        ),
1594                                    );
1595                                }
1596                                m_bigTriangles = _serde::__private::Some(
1597                                    match __A::next_value::<
1598                                        Vec<hkpCompressedMeshShapeBigTriangle>,
1599                                    >(&mut __map) {
1600                                        _serde::__private::Ok(__val) => __val,
1601                                        _serde::__private::Err(__err) => {
1602                                            return _serde::__private::Err(__err);
1603                                        }
1604                                    },
1605                                );
1606                            }
1607                            __Field::m_chunks => {
1608                                #[cfg(
1609                                    any(feature = "strict", feature = "ignore_duplicates")
1610                                )]
1611                                if _serde::__private::Option::is_some(&m_chunks) {
1612                                    #[cfg(feature = "ignore_duplicates")]
1613                                    {
1614                                        __A::skip_value(&mut __map)?;
1615                                        continue;
1616                                    }
1617                                    #[cfg(feature = "strict")]
1618                                    return _serde::__private::Err(
1619                                        <__A::Error as _serde::de::Error>::duplicate_field("chunks"),
1620                                    );
1621                                }
1622                                m_chunks = _serde::__private::Some(
1623                                    match __A::next_value::<
1624                                        Vec<hkpCompressedMeshShapeChunk>,
1625                                    >(&mut __map) {
1626                                        _serde::__private::Ok(__val) => __val,
1627                                        _serde::__private::Err(__err) => {
1628                                            return _serde::__private::Err(__err);
1629                                        }
1630                                    },
1631                                );
1632                            }
1633                            __Field::m_convexPieces => {
1634                                #[cfg(
1635                                    any(feature = "strict", feature = "ignore_duplicates")
1636                                )]
1637                                if _serde::__private::Option::is_some(&m_convexPieces) {
1638                                    #[cfg(feature = "ignore_duplicates")]
1639                                    {
1640                                        __A::skip_value(&mut __map)?;
1641                                        continue;
1642                                    }
1643                                    #[cfg(feature = "strict")]
1644                                    return _serde::__private::Err(
1645                                        <__A::Error as _serde::de::Error>::duplicate_field(
1646                                            "convexPieces",
1647                                        ),
1648                                    );
1649                                }
1650                                m_convexPieces = _serde::__private::Some(
1651                                    match __A::next_value::<
1652                                        Vec<hkpCompressedMeshShapeConvexPiece>,
1653                                    >(&mut __map) {
1654                                        _serde::__private::Ok(__val) => __val,
1655                                        _serde::__private::Err(__err) => {
1656                                            return _serde::__private::Err(__err);
1657                                        }
1658                                    },
1659                                );
1660                            }
1661                            __Field::m_error => {
1662                                #[cfg(
1663                                    any(feature = "strict", feature = "ignore_duplicates")
1664                                )]
1665                                if _serde::__private::Option::is_some(&m_error) {
1666                                    #[cfg(feature = "ignore_duplicates")]
1667                                    {
1668                                        __A::skip_value(&mut __map)?;
1669                                        continue;
1670                                    }
1671                                    #[cfg(feature = "strict")]
1672                                    return _serde::__private::Err(
1673                                        <__A::Error as _serde::de::Error>::duplicate_field("error"),
1674                                    );
1675                                }
1676                                m_error = _serde::__private::Some(
1677                                    match __A::next_value::<f32>(&mut __map) {
1678                                        _serde::__private::Ok(__val) => __val,
1679                                        _serde::__private::Err(__err) => {
1680                                            return _serde::__private::Err(__err);
1681                                        }
1682                                    },
1683                                );
1684                            }
1685                            __Field::m_bounds => {
1686                                #[cfg(
1687                                    any(feature = "strict", feature = "ignore_duplicates")
1688                                )]
1689                                if _serde::__private::Option::is_some(&m_bounds) {
1690                                    #[cfg(feature = "ignore_duplicates")]
1691                                    {
1692                                        __A::skip_value(&mut __map)?;
1693                                        continue;
1694                                    }
1695                                    #[cfg(feature = "strict")]
1696                                    return _serde::__private::Err(
1697                                        <__A::Error as _serde::de::Error>::duplicate_field("bounds"),
1698                                    );
1699                                }
1700                                m_bounds = _serde::__private::Some(
1701                                    match __A::next_value::<hkAabb>(&mut __map) {
1702                                        _serde::__private::Ok(__val) => __val,
1703                                        _serde::__private::Err(__err) => {
1704                                            return _serde::__private::Err(__err);
1705                                        }
1706                                    },
1707                                );
1708                            }
1709                            __Field::m_defaultCollisionFilterInfo => {
1710                                #[cfg(
1711                                    any(feature = "strict", feature = "ignore_duplicates")
1712                                )]
1713                                if _serde::__private::Option::is_some(
1714                                    &m_defaultCollisionFilterInfo,
1715                                ) {
1716                                    #[cfg(feature = "ignore_duplicates")]
1717                                    {
1718                                        __A::skip_value(&mut __map)?;
1719                                        continue;
1720                                    }
1721                                    #[cfg(feature = "strict")]
1722                                    return _serde::__private::Err(
1723                                        <__A::Error as _serde::de::Error>::duplicate_field(
1724                                            "defaultCollisionFilterInfo",
1725                                        ),
1726                                    );
1727                                }
1728                                m_defaultCollisionFilterInfo = _serde::__private::Some(
1729                                    match __A::next_value::<u32>(&mut __map) {
1730                                        _serde::__private::Ok(__val) => __val,
1731                                        _serde::__private::Err(__err) => {
1732                                            return _serde::__private::Err(__err);
1733                                        }
1734                                    },
1735                                );
1736                            }
1737                            __Field::m_materialStriding => {
1738                                #[cfg(
1739                                    any(feature = "strict", feature = "ignore_duplicates")
1740                                )]
1741                                if _serde::__private::Option::is_some(&m_materialStriding) {
1742                                    #[cfg(feature = "ignore_duplicates")]
1743                                    {
1744                                        __A::skip_value(&mut __map)?;
1745                                        continue;
1746                                    }
1747                                    #[cfg(feature = "strict")]
1748                                    return _serde::__private::Err(
1749                                        <__A::Error as _serde::de::Error>::duplicate_field(
1750                                            "materialStriding",
1751                                        ),
1752                                    );
1753                                }
1754                                m_materialStriding = _serde::__private::Some(
1755                                    match __A::next_value::<u16>(&mut __map) {
1756                                        _serde::__private::Ok(__val) => __val,
1757                                        _serde::__private::Err(__err) => {
1758                                            return _serde::__private::Err(__err);
1759                                        }
1760                                    },
1761                                );
1762                            }
1763                            __Field::m_numMaterials => {
1764                                #[cfg(
1765                                    any(feature = "strict", feature = "ignore_duplicates")
1766                                )]
1767                                if _serde::__private::Option::is_some(&m_numMaterials) {
1768                                    #[cfg(feature = "ignore_duplicates")]
1769                                    {
1770                                        __A::skip_value(&mut __map)?;
1771                                        continue;
1772                                    }
1773                                    #[cfg(feature = "strict")]
1774                                    return _serde::__private::Err(
1775                                        <__A::Error as _serde::de::Error>::duplicate_field(
1776                                            "numMaterials",
1777                                        ),
1778                                    );
1779                                }
1780                                m_numMaterials = _serde::__private::Some(
1781                                    match __A::next_value::<u16>(&mut __map) {
1782                                        _serde::__private::Ok(__val) => __val,
1783                                        _serde::__private::Err(__err) => {
1784                                            return _serde::__private::Err(__err);
1785                                        }
1786                                    },
1787                                );
1788                            }
1789                            __Field::m_namedMaterials => {
1790                                #[cfg(
1791                                    any(feature = "strict", feature = "ignore_duplicates")
1792                                )]
1793                                if _serde::__private::Option::is_some(&m_namedMaterials) {
1794                                    #[cfg(feature = "ignore_duplicates")]
1795                                    {
1796                                        __A::skip_value(&mut __map)?;
1797                                        continue;
1798                                    }
1799                                    #[cfg(feature = "strict")]
1800                                    return _serde::__private::Err(
1801                                        <__A::Error as _serde::de::Error>::duplicate_field(
1802                                            "namedMaterials",
1803                                        ),
1804                                    );
1805                                }
1806                                m_namedMaterials = _serde::__private::Some(
1807                                    match __A::next_value::<
1808                                        Vec<hkpNamedMeshMaterial<'de>>,
1809                                    >(&mut __map) {
1810                                        _serde::__private::Ok(__val) => __val,
1811                                        _serde::__private::Err(__err) => {
1812                                            return _serde::__private::Err(__err);
1813                                        }
1814                                    },
1815                                );
1816                            }
1817                            _ => __A::skip_value(&mut __map)?,
1818                        }
1819                    }
1820                    let m_userData = match m_userData {
1821                        _serde::__private::Some(__field) => __field,
1822                        _serde::__private::None => {
1823                            #[cfg(feature = "strict")]
1824                            return _serde::__private::Err(
1825                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1826                            );
1827                            #[cfg(not(feature = "strict"))] Default::default()
1828                        }
1829                    };
1830                    let m_disableWelding = match m_disableWelding {
1831                        _serde::__private::Some(__field) => __field,
1832                        _serde::__private::None => {
1833                            #[cfg(feature = "strict")]
1834                            return _serde::__private::Err(
1835                                <__A::Error as _serde::de::Error>::missing_field(
1836                                    "disableWelding",
1837                                ),
1838                            );
1839                            #[cfg(not(feature = "strict"))] Default::default()
1840                        }
1841                    };
1842                    let m_collectionType = match m_collectionType {
1843                        _serde::__private::Some(__field) => __field,
1844                        _serde::__private::None => {
1845                            #[cfg(feature = "strict")]
1846                            return _serde::__private::Err(
1847                                <__A::Error as _serde::de::Error>::missing_field(
1848                                    "collectionType",
1849                                ),
1850                            );
1851                            #[cfg(not(feature = "strict"))] Default::default()
1852                        }
1853                    };
1854                    let m_bitsPerIndex = match m_bitsPerIndex {
1855                        _serde::__private::Some(__field) => __field,
1856                        _serde::__private::None => {
1857                            #[cfg(feature = "strict")]
1858                            return _serde::__private::Err(
1859                                <__A::Error as _serde::de::Error>::missing_field(
1860                                    "bitsPerIndex",
1861                                ),
1862                            );
1863                            #[cfg(not(feature = "strict"))] Default::default()
1864                        }
1865                    };
1866                    let m_bitsPerWIndex = match m_bitsPerWIndex {
1867                        _serde::__private::Some(__field) => __field,
1868                        _serde::__private::None => {
1869                            #[cfg(feature = "strict")]
1870                            return _serde::__private::Err(
1871                                <__A::Error as _serde::de::Error>::missing_field(
1872                                    "bitsPerWIndex",
1873                                ),
1874                            );
1875                            #[cfg(not(feature = "strict"))] Default::default()
1876                        }
1877                    };
1878                    let m_wIndexMask = match m_wIndexMask {
1879                        _serde::__private::Some(__field) => __field,
1880                        _serde::__private::None => {
1881                            #[cfg(feature = "strict")]
1882                            return _serde::__private::Err(
1883                                <__A::Error as _serde::de::Error>::missing_field(
1884                                    "wIndexMask",
1885                                ),
1886                            );
1887                            #[cfg(not(feature = "strict"))] Default::default()
1888                        }
1889                    };
1890                    let m_indexMask = match m_indexMask {
1891                        _serde::__private::Some(__field) => __field,
1892                        _serde::__private::None => {
1893                            #[cfg(feature = "strict")]
1894                            return _serde::__private::Err(
1895                                <__A::Error as _serde::de::Error>::missing_field(
1896                                    "indexMask",
1897                                ),
1898                            );
1899                            #[cfg(not(feature = "strict"))] Default::default()
1900                        }
1901                    };
1902                    let m_radius = match m_radius {
1903                        _serde::__private::Some(__field) => __field,
1904                        _serde::__private::None => {
1905                            #[cfg(feature = "strict")]
1906                            return _serde::__private::Err(
1907                                <__A::Error as _serde::de::Error>::missing_field("radius"),
1908                            );
1909                            #[cfg(not(feature = "strict"))] Default::default()
1910                        }
1911                    };
1912                    let m_weldingType = match m_weldingType {
1913                        _serde::__private::Some(__field) => __field,
1914                        _serde::__private::None => {
1915                            #[cfg(feature = "strict")]
1916                            return _serde::__private::Err(
1917                                <__A::Error as _serde::de::Error>::missing_field(
1918                                    "weldingType",
1919                                ),
1920                            );
1921                            #[cfg(not(feature = "strict"))] Default::default()
1922                        }
1923                    };
1924                    let m_materialType = match m_materialType {
1925                        _serde::__private::Some(__field) => __field,
1926                        _serde::__private::None => {
1927                            #[cfg(feature = "strict")]
1928                            return _serde::__private::Err(
1929                                <__A::Error as _serde::de::Error>::missing_field(
1930                                    "materialType",
1931                                ),
1932                            );
1933                            #[cfg(not(feature = "strict"))] Default::default()
1934                        }
1935                    };
1936                    let m_materials = match m_materials {
1937                        _serde::__private::Some(__field) => __field,
1938                        _serde::__private::None => {
1939                            #[cfg(feature = "strict")]
1940                            return _serde::__private::Err(
1941                                <__A::Error as _serde::de::Error>::missing_field(
1942                                    "materials",
1943                                ),
1944                            );
1945                            #[cfg(not(feature = "strict"))] Default::default()
1946                        }
1947                    };
1948                    let m_materials16 = match m_materials16 {
1949                        _serde::__private::Some(__field) => __field,
1950                        _serde::__private::None => {
1951                            #[cfg(feature = "strict")]
1952                            return _serde::__private::Err(
1953                                <__A::Error as _serde::de::Error>::missing_field(
1954                                    "materials16",
1955                                ),
1956                            );
1957                            #[cfg(not(feature = "strict"))] Default::default()
1958                        }
1959                    };
1960                    let m_materials8 = match m_materials8 {
1961                        _serde::__private::Some(__field) => __field,
1962                        _serde::__private::None => {
1963                            #[cfg(feature = "strict")]
1964                            return _serde::__private::Err(
1965                                <__A::Error as _serde::de::Error>::missing_field(
1966                                    "materials8",
1967                                ),
1968                            );
1969                            #[cfg(not(feature = "strict"))] Default::default()
1970                        }
1971                    };
1972                    let m_transforms = match m_transforms {
1973                        _serde::__private::Some(__field) => __field,
1974                        _serde::__private::None => {
1975                            #[cfg(feature = "strict")]
1976                            return _serde::__private::Err(
1977                                <__A::Error as _serde::de::Error>::missing_field(
1978                                    "transforms",
1979                                ),
1980                            );
1981                            #[cfg(not(feature = "strict"))] Default::default()
1982                        }
1983                    };
1984                    let m_bigVertices = match m_bigVertices {
1985                        _serde::__private::Some(__field) => __field,
1986                        _serde::__private::None => {
1987                            #[cfg(feature = "strict")]
1988                            return _serde::__private::Err(
1989                                <__A::Error as _serde::de::Error>::missing_field(
1990                                    "bigVertices",
1991                                ),
1992                            );
1993                            #[cfg(not(feature = "strict"))] Default::default()
1994                        }
1995                    };
1996                    let m_bigTriangles = match m_bigTriangles {
1997                        _serde::__private::Some(__field) => __field,
1998                        _serde::__private::None => {
1999                            #[cfg(feature = "strict")]
2000                            return _serde::__private::Err(
2001                                <__A::Error as _serde::de::Error>::missing_field(
2002                                    "bigTriangles",
2003                                ),
2004                            );
2005                            #[cfg(not(feature = "strict"))] Default::default()
2006                        }
2007                    };
2008                    let m_chunks = match m_chunks {
2009                        _serde::__private::Some(__field) => __field,
2010                        _serde::__private::None => {
2011                            #[cfg(feature = "strict")]
2012                            return _serde::__private::Err(
2013                                <__A::Error as _serde::de::Error>::missing_field("chunks"),
2014                            );
2015                            #[cfg(not(feature = "strict"))] Default::default()
2016                        }
2017                    };
2018                    let m_convexPieces = match m_convexPieces {
2019                        _serde::__private::Some(__field) => __field,
2020                        _serde::__private::None => {
2021                            #[cfg(feature = "strict")]
2022                            return _serde::__private::Err(
2023                                <__A::Error as _serde::de::Error>::missing_field(
2024                                    "convexPieces",
2025                                ),
2026                            );
2027                            #[cfg(not(feature = "strict"))] Default::default()
2028                        }
2029                    };
2030                    let m_error = match m_error {
2031                        _serde::__private::Some(__field) => __field,
2032                        _serde::__private::None => {
2033                            #[cfg(feature = "strict")]
2034                            return _serde::__private::Err(
2035                                <__A::Error as _serde::de::Error>::missing_field("error"),
2036                            );
2037                            #[cfg(not(feature = "strict"))] Default::default()
2038                        }
2039                    };
2040                    let m_bounds = match m_bounds {
2041                        _serde::__private::Some(__field) => __field,
2042                        _serde::__private::None => {
2043                            #[cfg(feature = "strict")]
2044                            return _serde::__private::Err(
2045                                <__A::Error as _serde::de::Error>::missing_field("bounds"),
2046                            );
2047                            #[cfg(not(feature = "strict"))] Default::default()
2048                        }
2049                    };
2050                    let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
2051                        _serde::__private::Some(__field) => __field,
2052                        _serde::__private::None => {
2053                            #[cfg(feature = "strict")]
2054                            return _serde::__private::Err(
2055                                <__A::Error as _serde::de::Error>::missing_field(
2056                                    "defaultCollisionFilterInfo",
2057                                ),
2058                            );
2059                            #[cfg(not(feature = "strict"))] Default::default()
2060                        }
2061                    };
2062                    let m_materialStriding = match m_materialStriding {
2063                        _serde::__private::Some(__field) => __field,
2064                        _serde::__private::None => {
2065                            #[cfg(feature = "strict")]
2066                            return _serde::__private::Err(
2067                                <__A::Error as _serde::de::Error>::missing_field(
2068                                    "materialStriding",
2069                                ),
2070                            );
2071                            #[cfg(not(feature = "strict"))] Default::default()
2072                        }
2073                    };
2074                    let m_numMaterials = match m_numMaterials {
2075                        _serde::__private::Some(__field) => __field,
2076                        _serde::__private::None => {
2077                            #[cfg(feature = "strict")]
2078                            return _serde::__private::Err(
2079                                <__A::Error as _serde::de::Error>::missing_field(
2080                                    "numMaterials",
2081                                ),
2082                            );
2083                            #[cfg(not(feature = "strict"))] Default::default()
2084                        }
2085                    };
2086                    let m_namedMaterials = match m_namedMaterials {
2087                        _serde::__private::Some(__field) => __field,
2088                        _serde::__private::None => {
2089                            #[cfg(feature = "strict")]
2090                            return _serde::__private::Err(
2091                                <__A::Error as _serde::de::Error>::missing_field(
2092                                    "namedMaterials",
2093                                ),
2094                            );
2095                            #[cfg(not(feature = "strict"))] Default::default()
2096                        }
2097                    };
2098                    let __ptr = None;
2099                    let parent = hkBaseObject { __ptr };
2100                    let parent = hkReferencedObject {
2101                        __ptr,
2102                        parent,
2103                        ..Default::default()
2104                    };
2105                    let parent = hkpShape {
2106                        __ptr,
2107                        parent,
2108                        m_userData,
2109                        ..Default::default()
2110                    };
2111                    let parent = hkpShapeCollection {
2112                        __ptr,
2113                        parent,
2114                        m_disableWelding,
2115                        m_collectionType,
2116                    };
2117                    let __ptr = __A::class_ptr(&mut __map);
2118                    _serde::__private::Ok(hkpCompressedMeshShape {
2119                        __ptr,
2120                        parent,
2121                        m_bitsPerIndex,
2122                        m_bitsPerWIndex,
2123                        m_wIndexMask,
2124                        m_indexMask,
2125                        m_radius,
2126                        m_weldingType,
2127                        m_materialType,
2128                        m_materials,
2129                        m_materials16,
2130                        m_materials8,
2131                        m_transforms,
2132                        m_bigVertices,
2133                        m_bigTriangles,
2134                        m_chunks,
2135                        m_convexPieces,
2136                        m_error,
2137                        m_bounds,
2138                        m_defaultCollisionFilterInfo,
2139                        m_materialStriding,
2140                        m_numMaterials,
2141                        m_namedMaterials,
2142                        ..Default::default()
2143                    })
2144                }
2145            }
2146            const FIELDS: &[&str] = &[
2147                "bitsPerIndex",
2148                "bitsPerWIndex",
2149                "wIndexMask",
2150                "indexMask",
2151                "radius",
2152                "weldingType",
2153                "materialType",
2154                "materials",
2155                "materials16",
2156                "materials8",
2157                "transforms",
2158                "bigVertices",
2159                "bigTriangles",
2160                "chunks",
2161                "convexPieces",
2162                "error",
2163                "bounds",
2164                "defaultCollisionFilterInfo",
2165                "meshMaterials",
2166                "materialStriding",
2167                "numMaterials",
2168                "namedMaterials",
2169            ];
2170            _serde::Deserializer::deserialize_struct(
2171                deserializer,
2172                "hkpCompressedMeshShape",
2173                FIELDS,
2174                __hkpCompressedMeshShapeVisitor {
2175                    marker: _serde::__private::PhantomData::<hkpCompressedMeshShape>,
2176                    lifetime: _serde::__private::PhantomData,
2177                },
2178            )
2179        }
2180    }
2181};
2182/// # C++ Info
2183/// - name: `MaterialType`(ctype: `hkEnum<MaterialType, hkUint8>`)
2184#[allow(non_upper_case_globals, non_snake_case)]
2185#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2186#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2187#[derive(
2188    Debug,
2189    Clone,
2190    Default,
2191    PartialEq,
2192    Eq,
2193    PartialOrd,
2194    Ord,
2195    num_derive::ToPrimitive,
2196    num_derive::FromPrimitive,
2197)]
2198pub enum MaterialType {
2199    #[default]
2200    MATERIAL_NONE = 0isize,
2201    MATERIAL_SINGLE_VALUE_PER_CHUNK = 1isize,
2202    MATERIAL_ONE_BYTE_PER_TRIANGLE = 2isize,
2203    MATERIAL_TWO_BYTES_PER_TRIANGLE = 3isize,
2204    MATERIAL_FOUR_BYTES_PER_TRIANGLE = 4isize,
2205}
2206const _: () = {
2207    use havok_serde as __serde;
2208    impl __serde::Serialize for MaterialType {
2209        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2210        where
2211            S: __serde::ser::Serializer,
2212        {
2213            let mut __serializer = __serializer.serialize_enum_flags()?;
2214            match self {
2215                Self::MATERIAL_NONE => {
2216                    __serializer.serialize_field("MATERIAL_NONE", &0u64)
2217                }
2218                Self::MATERIAL_SINGLE_VALUE_PER_CHUNK => {
2219                    __serializer
2220                        .serialize_field("MATERIAL_SINGLE_VALUE_PER_CHUNK", &1u64)
2221                }
2222                Self::MATERIAL_ONE_BYTE_PER_TRIANGLE => {
2223                    __serializer.serialize_field("MATERIAL_ONE_BYTE_PER_TRIANGLE", &2u64)
2224                }
2225                Self::MATERIAL_TWO_BYTES_PER_TRIANGLE => {
2226                    __serializer
2227                        .serialize_field("MATERIAL_TWO_BYTES_PER_TRIANGLE", &3u64)
2228                }
2229                Self::MATERIAL_FOUR_BYTES_PER_TRIANGLE => {
2230                    __serializer
2231                        .serialize_field("MATERIAL_FOUR_BYTES_PER_TRIANGLE", &4u64)
2232                }
2233            }?;
2234            use num_traits::ToPrimitive as _;
2235            let num = self
2236                .to_u8()
2237                .ok_or(S::Error::custom("Failed enum MaterialType to_u8"))?;
2238            __serializer.serialize_bits(&num)?;
2239            __serializer.end()
2240        }
2241    }
2242};
2243#[doc(hidden)]
2244#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2245const _: () = {
2246    #[allow(unused_extern_crates, clippy::useless_attribute)]
2247    extern crate havok_serde as _serde;
2248    #[automatically_derived]
2249    impl<'de> _serde::Deserialize<'de> for MaterialType {
2250        fn deserialize<__D>(
2251            __deserializer: __D,
2252        ) -> _serde::__private::Result<Self, __D::Error>
2253        where
2254            __D: _serde::Deserializer<'de>,
2255        {
2256            #[allow(non_camel_case_types)]
2257            #[doc(hidden)]
2258            enum __Field {
2259                __field0,
2260                __field1,
2261                __field2,
2262                __field3,
2263                __field4,
2264            }
2265            #[doc(hidden)]
2266            struct __FieldVisitor;
2267            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2268                type Value = __Field;
2269                fn expecting(
2270                    &self,
2271                    __formatter: &mut _serde::__private::Formatter,
2272                ) -> _serde::__private::fmt::Result {
2273                    _serde::__private::Formatter::write_str(
2274                        __formatter,
2275                        "variant identifier",
2276                    )
2277                }
2278                fn visit_uint8<__E>(
2279                    self,
2280                    __value: u8,
2281                ) -> _serde::__private::Result<Self::Value, __E>
2282                where
2283                    __E: _serde::de::Error,
2284                {
2285                    match __value {
2286                        0u8 => _serde::__private::Ok(__Field::__field0),
2287                        1u8 => _serde::__private::Ok(__Field::__field1),
2288                        2u8 => _serde::__private::Ok(__Field::__field2),
2289                        3u8 => _serde::__private::Ok(__Field::__field3),
2290                        4u8 => _serde::__private::Ok(__Field::__field4),
2291                        _ => {
2292                            _serde::__private::Err(
2293                                _serde::de::Error::invalid_value(
2294                                    _serde::de::Unexpected::Uint8(__value),
2295                                    &"value(u8) of variant is one of 0, 1, 2, 3, 4",
2296                                ),
2297                            )
2298                        }
2299                    }
2300                }
2301                fn visit_stringptr<__E>(
2302                    self,
2303                    __value: StringPtr<'de>,
2304                ) -> _serde::__private::Result<Self::Value, __E>
2305                where
2306                    __E: _serde::de::Error,
2307                {
2308                    if let Some(__value) = __value.into_inner() {
2309                        match __value.as_ref() {
2310                            v if v == "0" || v.eq_ignore_ascii_case("MATERIAL_NONE") => {
2311                                _serde::__private::Ok(__Field::__field0)
2312                            }
2313                            v if v == "1"
2314                                || v
2315                                    .eq_ignore_ascii_case("MATERIAL_SINGLE_VALUE_PER_CHUNK") => {
2316                                _serde::__private::Ok(__Field::__field1)
2317                            }
2318                            v if v == "2"
2319                                || v
2320                                    .eq_ignore_ascii_case("MATERIAL_ONE_BYTE_PER_TRIANGLE") => {
2321                                _serde::__private::Ok(__Field::__field2)
2322                            }
2323                            v if v == "3"
2324                                || v
2325                                    .eq_ignore_ascii_case("MATERIAL_TWO_BYTES_PER_TRIANGLE") => {
2326                                _serde::__private::Ok(__Field::__field3)
2327                            }
2328                            v if v == "4"
2329                                || v
2330                                    .eq_ignore_ascii_case(
2331                                        "MATERIAL_FOUR_BYTES_PER_TRIANGLE",
2332                                    ) => _serde::__private::Ok(__Field::__field4),
2333                            _ => {
2334                                _serde::__private::Err(
2335                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
2336                                )
2337                            }
2338                        }
2339                    } else {
2340                        _serde::__private::Err(
2341                            _serde::de::Error::unknown_variant("None", VARIANTS),
2342                        )
2343                    }
2344                }
2345            }
2346            impl<'de> _serde::Deserialize<'de> for __Field {
2347                #[inline]
2348                fn deserialize<__D>(
2349                    __deserializer: __D,
2350                ) -> _serde::__private::Result<Self, __D::Error>
2351                where
2352                    __D: _serde::Deserializer<'de>,
2353                {
2354                    _serde::Deserializer::deserialize_identifier(
2355                        __deserializer,
2356                        _serde::de::ReadEnumSize::Uint8,
2357                        __FieldVisitor,
2358                    )
2359                }
2360            }
2361            #[doc(hidden)]
2362            struct __Visitor<'de> {
2363                marker: _serde::__private::PhantomData<MaterialType>,
2364                lifetime: _serde::__private::PhantomData<&'de ()>,
2365            }
2366            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2367                type Value = MaterialType;
2368                fn expecting(
2369                    &self,
2370                    __formatter: &mut _serde::__private::Formatter,
2371                ) -> _serde::__private::fmt::Result {
2372                    _serde::__private::Formatter::write_str(
2373                        __formatter,
2374                        "enum MaterialType",
2375                    )
2376                }
2377                fn visit_enum<__A>(
2378                    self,
2379                    __data: __A,
2380                ) -> _serde::__private::Result<Self::Value, __A::Error>
2381                where
2382                    __A: _serde::de::EnumAccess<'de>,
2383                {
2384                    match _serde::de::EnumAccess::variant(__data)? {
2385                        (__Field::__field0, __variant) => {
2386                            _serde::de::VariantAccess::unit_variant(__variant)?;
2387                            _serde::__private::Ok(MaterialType::MATERIAL_NONE)
2388                        }
2389                        (__Field::__field1, __variant) => {
2390                            _serde::de::VariantAccess::unit_variant(__variant)?;
2391                            _serde::__private::Ok(
2392                                MaterialType::MATERIAL_SINGLE_VALUE_PER_CHUNK,
2393                            )
2394                        }
2395                        (__Field::__field2, __variant) => {
2396                            _serde::de::VariantAccess::unit_variant(__variant)?;
2397                            _serde::__private::Ok(
2398                                MaterialType::MATERIAL_ONE_BYTE_PER_TRIANGLE,
2399                            )
2400                        }
2401                        (__Field::__field3, __variant) => {
2402                            _serde::de::VariantAccess::unit_variant(__variant)?;
2403                            _serde::__private::Ok(
2404                                MaterialType::MATERIAL_TWO_BYTES_PER_TRIANGLE,
2405                            )
2406                        }
2407                        (__Field::__field4, __variant) => {
2408                            _serde::de::VariantAccess::unit_variant(__variant)?;
2409                            _serde::__private::Ok(
2410                                MaterialType::MATERIAL_FOUR_BYTES_PER_TRIANGLE,
2411                            )
2412                        }
2413                    }
2414                }
2415            }
2416            #[doc(hidden)]
2417            const VARIANTS: &'static [&'static str] = &[
2418                "MATERIAL_NONE",
2419                "MATERIAL_SINGLE_VALUE_PER_CHUNK",
2420                "MATERIAL_ONE_BYTE_PER_TRIANGLE",
2421                "MATERIAL_TWO_BYTES_PER_TRIANGLE",
2422                "MATERIAL_FOUR_BYTES_PER_TRIANGLE",
2423            ];
2424            _serde::Deserializer::deserialize_enum(
2425                __deserializer,
2426                "MaterialType",
2427                VARIANTS,
2428                __Visitor {
2429                    marker: _serde::__private::PhantomData::<MaterialType>,
2430                    lifetime: _serde::__private::PhantomData,
2431                },
2432            )
2433        }
2434    }
2435};