havok_classes/generated/
hkpExtendedMeshShape_.rs

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