havok_classes/generated/
hkpStorageExtendedMeshShape_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpStorageExtendedMeshShape`
5/// - version: `0`
6/// - signature: `0xb469efbc`
7/// - size: `272`(x86)/`368`(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 hkpStorageExtendedMeshShape {
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: hkpExtendedMeshShape,
30    /// # C++ Info
31    /// - name: `meshstorage`(ctype: `hkArray<hkpStorageExtendedMeshShapeMeshSubpartStorage*>`)
32    /// - offset: `240`(x86)/`336`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "meshstorage"))]
35    #[cfg_attr(feature = "serde", serde(rename = "meshstorage"))]
36    pub m_meshstorage: Vec<Pointer>,
37    /// # C++ Info
38    /// - name: `shapestorage`(ctype: `hkArray<hkpStorageExtendedMeshShapeShapeSubpartStorage*>`)
39    /// - offset: `252`(x86)/`352`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "shapestorage"))]
42    #[cfg_attr(feature = "serde", serde(rename = "shapestorage"))]
43    pub m_shapestorage: Vec<Pointer>,
44}
45const _: () = {
46    use havok_serde as _serde;
47    impl _serde::HavokClass for hkpStorageExtendedMeshShape {
48        #[inline]
49        fn name(&self) -> &'static str {
50            "hkpStorageExtendedMeshShape"
51        }
52        #[inline]
53        fn signature(&self) -> _serde::__private::Signature {
54            _serde::__private::Signature::new(0xb469efbc)
55        }
56        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
57        fn deps_indexes(&self) -> Vec<usize> {
58            let mut v = Vec::new();
59            v.extend(self.parent.m_embeddedTrianglesSubpart.deps_indexes());
60            v.push(self.parent.m_materialClass.get());
61            v.extend(
62                self
63                    .parent
64                    .m_trianglesSubparts
65                    .iter()
66                    .flat_map(|class| class.deps_indexes())
67                    .collect::<Vec<usize>>(),
68            );
69            v.extend(
70                self
71                    .parent
72                    .m_shapesSubparts
73                    .iter()
74                    .flat_map(|class| class.deps_indexes())
75                    .collect::<Vec<usize>>(),
76            );
77            v.extend(self.m_meshstorage.iter().map(|ptr| ptr.get()));
78            v.extend(self.m_shapestorage.iter().map(|ptr| ptr.get()));
79            v
80        }
81    }
82    impl _serde::Serialize for hkpStorageExtendedMeshShape {
83        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
84        where
85            S: _serde::ser::Serializer,
86        {
87            let class_meta = self
88                .__ptr
89                .map(|name| (name, _serde::__private::Signature::new(0xb469efbc)));
90            let mut serializer = __serializer
91                .serialize_struct(
92                    "hkpStorageExtendedMeshShape",
93                    class_meta,
94                    (272u64, 368u64),
95                )?;
96            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
97            serializer
98                .skip_field(
99                    "memSizeAndFlags",
100                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
101                )?;
102            serializer
103                .skip_field(
104                    "referenceCount",
105                    &self.parent.parent.parent.parent.m_referenceCount,
106                )?;
107            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
108            serializer
109                .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
110            serializer.skip_field("type", &self.parent.parent.parent.m_type)?;
111            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
112            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
113            serializer
114                .serialize_field(
115                    "disableWelding",
116                    &self.parent.parent.m_disableWelding,
117                )?;
118            serializer
119                .serialize_field(
120                    "collectionType",
121                    &self.parent.parent.m_collectionType,
122                )?;
123            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
124            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
125            serializer
126                .serialize_field(
127                    "embeddedTrianglesSubpart",
128                    &self.parent.m_embeddedTrianglesSubpart,
129                )?;
130            serializer
131                .serialize_field("aabbHalfExtents", &self.parent.m_aabbHalfExtents)?;
132            serializer.serialize_field("aabbCenter", &self.parent.m_aabbCenter)?;
133            serializer.skip_field("materialClass", &self.parent.m_materialClass)?;
134            serializer
135                .serialize_field(
136                    "numBitsForSubpartIndex",
137                    &self.parent.m_numBitsForSubpartIndex,
138                )?;
139            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
140            serializer
141                .serialize_array_field(
142                    "trianglesSubparts",
143                    &self.parent.m_trianglesSubparts,
144                    TypeSize::Struct {
145                        size_x86: 112u64,
146                        size_x86_64: 160u64,
147                    },
148                )?;
149            serializer
150                .serialize_array_field(
151                    "shapesSubparts",
152                    &self.parent.m_shapesSubparts,
153                    TypeSize::Struct {
154                        size_x86: 64u64,
155                        size_x86_64: 96u64,
156                    },
157                )?;
158            serializer
159                .serialize_array_field(
160                    "weldingInfo",
161                    &self.parent.m_weldingInfo,
162                    TypeSize::NonPtr,
163                )?;
164            serializer.serialize_field("weldingType", &self.parent.m_weldingType)?;
165            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
166            serializer
167                .serialize_field(
168                    "defaultCollisionFilterInfo",
169                    &self.parent.m_defaultCollisionFilterInfo,
170                )?;
171            serializer
172                .serialize_field(
173                    "cachedNumChildShapes",
174                    &self.parent.m_cachedNumChildShapes,
175                )?;
176            serializer.serialize_field("triangleRadius", &self.parent.m_triangleRadius)?;
177            serializer.skip_field("padding", &self.parent.m_padding)?;
178            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 12usize].as_slice())?;
179            serializer
180                .serialize_array_field(
181                    "meshstorage",
182                    &self.m_meshstorage,
183                    TypeSize::NonPtr,
184                )?;
185            serializer
186                .serialize_array_field(
187                    "shapestorage",
188                    &self.m_shapestorage,
189                    TypeSize::NonPtr,
190                )?;
191            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
192            serializer.end()
193        }
194    }
195};
196#[doc(hidden)]
197#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
198const _: () = {
199    use havok_serde as _serde;
200    #[automatically_derived]
201    impl<'de> _serde::Deserialize<'de> for hkpStorageExtendedMeshShape {
202        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
203        where
204            __D: _serde::Deserializer<'de>,
205        {
206            #[allow(non_camel_case_types)]
207            enum __Field {
208                m_userData,
209                m_disableWelding,
210                m_collectionType,
211                m_embeddedTrianglesSubpart,
212                m_aabbHalfExtents,
213                m_aabbCenter,
214                m_numBitsForSubpartIndex,
215                m_trianglesSubparts,
216                m_shapesSubparts,
217                m_weldingInfo,
218                m_weldingType,
219                m_defaultCollisionFilterInfo,
220                m_cachedNumChildShapes,
221                m_triangleRadius,
222                m_meshstorage,
223                m_shapestorage,
224                __ignore,
225            }
226            struct __FieldVisitor;
227            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
228                type Value = __Field;
229                fn expecting(
230                    &self,
231                    __formatter: &mut core::fmt::Formatter,
232                ) -> core::fmt::Result {
233                    core::fmt::Formatter::write_str(__formatter, "field identifier")
234                }
235                /// Intended for use in XML.
236                #[allow(clippy::match_single_binding)]
237                #[allow(clippy::reversed_empty_ranges)]
238                #[allow(clippy::single_match)]
239                fn visit_key<__E>(
240                    self,
241                    __value: &str,
242                ) -> core::result::Result<Self::Value, __E>
243                where
244                    __E: _serde::de::Error,
245                {
246                    match __value {
247                        "userData" => Ok(__Field::m_userData),
248                        "disableWelding" => Ok(__Field::m_disableWelding),
249                        "collectionType" => Ok(__Field::m_collectionType),
250                        "embeddedTrianglesSubpart" => {
251                            Ok(__Field::m_embeddedTrianglesSubpart)
252                        }
253                        "aabbHalfExtents" => Ok(__Field::m_aabbHalfExtents),
254                        "aabbCenter" => Ok(__Field::m_aabbCenter),
255                        "numBitsForSubpartIndex" => Ok(__Field::m_numBitsForSubpartIndex),
256                        "trianglesSubparts" => Ok(__Field::m_trianglesSubparts),
257                        "shapesSubparts" => Ok(__Field::m_shapesSubparts),
258                        "weldingInfo" => Ok(__Field::m_weldingInfo),
259                        "weldingType" => Ok(__Field::m_weldingType),
260                        "defaultCollisionFilterInfo" => {
261                            Ok(__Field::m_defaultCollisionFilterInfo)
262                        }
263                        "cachedNumChildShapes" => Ok(__Field::m_cachedNumChildShapes),
264                        "triangleRadius" => Ok(__Field::m_triangleRadius),
265                        "meshstorage" => Ok(__Field::m_meshstorage),
266                        "shapestorage" => Ok(__Field::m_shapestorage),
267                        _ => Ok(__Field::__ignore),
268                    }
269                }
270            }
271            impl<'de> _serde::Deserialize<'de> for __Field {
272                #[inline]
273                fn deserialize<__D>(
274                    __deserializer: __D,
275                ) -> core::result::Result<Self, __D::Error>
276                where
277                    __D: _serde::Deserializer<'de>,
278                {
279                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
280                }
281            }
282            struct __hkpStorageExtendedMeshShapeVisitor<'de> {
283                marker: _serde::__private::PhantomData<hkpStorageExtendedMeshShape>,
284                lifetime: _serde::__private::PhantomData<&'de ()>,
285            }
286            #[allow(clippy::match_single_binding)]
287            #[allow(clippy::reversed_empty_ranges)]
288            #[allow(clippy::single_match)]
289            impl<'de> _serde::de::Visitor<'de>
290            for __hkpStorageExtendedMeshShapeVisitor<'de> {
291                type Value = hkpStorageExtendedMeshShape;
292                fn expecting(
293                    &self,
294                    __formatter: &mut core::fmt::Formatter,
295                ) -> core::fmt::Result {
296                    core::fmt::Formatter::write_str(
297                        __formatter,
298                        "struct hkpStorageExtendedMeshShape",
299                    )
300                }
301                fn visit_struct_for_bytes<__A>(
302                    self,
303                    mut __map: __A,
304                ) -> _serde::__private::Result<Self::Value, __A::Error>
305                where
306                    __A: _serde::de::MapAccess<'de>,
307                {
308                    let __ptr = __A::class_ptr(&mut __map);
309                    let parent = __A::parent_value(&mut __map)?;
310                    let mut m_meshstorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
311                    let mut m_shapestorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
312                    for i in 0..2usize {
313                        match i {
314                            0usize => {
315                                if _serde::__private::Option::is_some(&m_meshstorage) {
316                                    return _serde::__private::Err(
317                                        <__A::Error as _serde::de::Error>::duplicate_field(
318                                            "meshstorage",
319                                        ),
320                                    );
321                                }
322                                m_meshstorage = _serde::__private::Some(
323                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
324                                        _serde::__private::Ok(__val) => __val,
325                                        _serde::__private::Err(__err) => {
326                                            return _serde::__private::Err(__err);
327                                        }
328                                    },
329                                );
330                            }
331                            1usize => {
332                                if _serde::__private::Option::is_some(&m_shapestorage) {
333                                    return _serde::__private::Err(
334                                        <__A::Error as _serde::de::Error>::duplicate_field(
335                                            "shapestorage",
336                                        ),
337                                    );
338                                }
339                                m_shapestorage = _serde::__private::Some(
340                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
341                                        _serde::__private::Ok(__val) => __val,
342                                        _serde::__private::Err(__err) => {
343                                            return _serde::__private::Err(__err);
344                                        }
345                                    },
346                                );
347                            }
348                            _ => {}
349                        }
350                    }
351                    __A::pad(&mut __map, 8usize, 0usize)?;
352                    let m_meshstorage = match m_meshstorage {
353                        _serde::__private::Some(__field) => __field,
354                        _serde::__private::None => {
355                            return _serde::__private::Err(
356                                <__A::Error as _serde::de::Error>::missing_field(
357                                    "meshstorage",
358                                ),
359                            );
360                        }
361                    };
362                    let m_shapestorage = match m_shapestorage {
363                        _serde::__private::Some(__field) => __field,
364                        _serde::__private::None => {
365                            return _serde::__private::Err(
366                                <__A::Error as _serde::de::Error>::missing_field(
367                                    "shapestorage",
368                                ),
369                            );
370                        }
371                    };
372                    _serde::__private::Ok(hkpStorageExtendedMeshShape {
373                        __ptr,
374                        parent,
375                        m_meshstorage,
376                        m_shapestorage,
377                    })
378                }
379                #[allow(clippy::manual_unwrap_or_default)]
380                fn visit_struct<__A>(
381                    self,
382                    mut __map: __A,
383                ) -> _serde::__private::Result<Self::Value, __A::Error>
384                where
385                    __A: _serde::de::MapAccess<'de>,
386                {
387                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
388                    let mut m_disableWelding: _serde::__private::Option<bool> = _serde::__private::None;
389                    let mut m_collectionType: _serde::__private::Option<
390                        CollectionType,
391                    > = _serde::__private::None;
392                    let mut m_embeddedTrianglesSubpart: _serde::__private::Option<
393                        hkpExtendedMeshShapeTrianglesSubpart,
394                    > = _serde::__private::None;
395                    let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
396                    let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
397                    let mut m_numBitsForSubpartIndex: _serde::__private::Option<i32> = _serde::__private::None;
398                    let mut m_trianglesSubparts: _serde::__private::Option<
399                        Vec<hkpExtendedMeshShapeTrianglesSubpart>,
400                    > = _serde::__private::None;
401                    let mut m_shapesSubparts: _serde::__private::Option<
402                        Vec<hkpExtendedMeshShapeShapesSubpart>,
403                    > = _serde::__private::None;
404                    let mut m_weldingInfo: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
405                    let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
406                    let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
407                        u32,
408                    > = _serde::__private::None;
409                    let mut m_cachedNumChildShapes: _serde::__private::Option<i32> = _serde::__private::None;
410                    let mut m_triangleRadius: _serde::__private::Option<f32> = _serde::__private::None;
411                    let mut m_meshstorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
412                    let mut m_shapestorage: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
413                    while let _serde::__private::Some(__key) = {
414                        __A::next_key::<__Field>(&mut __map)?
415                    } {
416                        match __key {
417                            __Field::m_userData => {
418                                #[cfg(
419                                    any(feature = "strict", feature = "ignore_duplicates")
420                                )]
421                                if _serde::__private::Option::is_some(&m_userData) {
422                                    #[cfg(feature = "ignore_duplicates")]
423                                    {
424                                        __A::skip_value(&mut __map)?;
425                                        continue;
426                                    }
427                                    #[cfg(feature = "strict")]
428                                    return _serde::__private::Err(
429                                        <__A::Error as _serde::de::Error>::duplicate_field(
430                                            "userData",
431                                        ),
432                                    );
433                                }
434                                m_userData = _serde::__private::Some(
435                                    match __A::next_value::<Ulong>(&mut __map) {
436                                        _serde::__private::Ok(__val) => __val,
437                                        _serde::__private::Err(__err) => {
438                                            return _serde::__private::Err(__err);
439                                        }
440                                    },
441                                );
442                            }
443                            __Field::m_disableWelding => {
444                                #[cfg(
445                                    any(feature = "strict", feature = "ignore_duplicates")
446                                )]
447                                if _serde::__private::Option::is_some(&m_disableWelding) {
448                                    #[cfg(feature = "ignore_duplicates")]
449                                    {
450                                        __A::skip_value(&mut __map)?;
451                                        continue;
452                                    }
453                                    #[cfg(feature = "strict")]
454                                    return _serde::__private::Err(
455                                        <__A::Error as _serde::de::Error>::duplicate_field(
456                                            "disableWelding",
457                                        ),
458                                    );
459                                }
460                                m_disableWelding = _serde::__private::Some(
461                                    match __A::next_value::<bool>(&mut __map) {
462                                        _serde::__private::Ok(__val) => __val,
463                                        _serde::__private::Err(__err) => {
464                                            return _serde::__private::Err(__err);
465                                        }
466                                    },
467                                );
468                            }
469                            __Field::m_collectionType => {
470                                #[cfg(
471                                    any(feature = "strict", feature = "ignore_duplicates")
472                                )]
473                                if _serde::__private::Option::is_some(&m_collectionType) {
474                                    #[cfg(feature = "ignore_duplicates")]
475                                    {
476                                        __A::skip_value(&mut __map)?;
477                                        continue;
478                                    }
479                                    #[cfg(feature = "strict")]
480                                    return _serde::__private::Err(
481                                        <__A::Error as _serde::de::Error>::duplicate_field(
482                                            "collectionType",
483                                        ),
484                                    );
485                                }
486                                m_collectionType = _serde::__private::Some(
487                                    match __A::next_value::<CollectionType>(&mut __map) {
488                                        _serde::__private::Ok(__val) => __val,
489                                        _serde::__private::Err(__err) => {
490                                            return _serde::__private::Err(__err);
491                                        }
492                                    },
493                                );
494                            }
495                            __Field::m_embeddedTrianglesSubpart => {
496                                #[cfg(
497                                    any(feature = "strict", feature = "ignore_duplicates")
498                                )]
499                                if _serde::__private::Option::is_some(
500                                    &m_embeddedTrianglesSubpart,
501                                ) {
502                                    #[cfg(feature = "ignore_duplicates")]
503                                    {
504                                        __A::skip_value(&mut __map)?;
505                                        continue;
506                                    }
507                                    #[cfg(feature = "strict")]
508                                    return _serde::__private::Err(
509                                        <__A::Error as _serde::de::Error>::duplicate_field(
510                                            "embeddedTrianglesSubpart",
511                                        ),
512                                    );
513                                }
514                                m_embeddedTrianglesSubpart = _serde::__private::Some(
515                                    match __A::next_value::<
516                                        hkpExtendedMeshShapeTrianglesSubpart,
517                                    >(&mut __map) {
518                                        _serde::__private::Ok(__val) => __val,
519                                        _serde::__private::Err(__err) => {
520                                            return _serde::__private::Err(__err);
521                                        }
522                                    },
523                                );
524                            }
525                            __Field::m_aabbHalfExtents => {
526                                #[cfg(
527                                    any(feature = "strict", feature = "ignore_duplicates")
528                                )]
529                                if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
530                                    #[cfg(feature = "ignore_duplicates")]
531                                    {
532                                        __A::skip_value(&mut __map)?;
533                                        continue;
534                                    }
535                                    #[cfg(feature = "strict")]
536                                    return _serde::__private::Err(
537                                        <__A::Error as _serde::de::Error>::duplicate_field(
538                                            "aabbHalfExtents",
539                                        ),
540                                    );
541                                }
542                                m_aabbHalfExtents = _serde::__private::Some(
543                                    match __A::next_value::<Vector4>(&mut __map) {
544                                        _serde::__private::Ok(__val) => __val,
545                                        _serde::__private::Err(__err) => {
546                                            return _serde::__private::Err(__err);
547                                        }
548                                    },
549                                );
550                            }
551                            __Field::m_aabbCenter => {
552                                #[cfg(
553                                    any(feature = "strict", feature = "ignore_duplicates")
554                                )]
555                                if _serde::__private::Option::is_some(&m_aabbCenter) {
556                                    #[cfg(feature = "ignore_duplicates")]
557                                    {
558                                        __A::skip_value(&mut __map)?;
559                                        continue;
560                                    }
561                                    #[cfg(feature = "strict")]
562                                    return _serde::__private::Err(
563                                        <__A::Error as _serde::de::Error>::duplicate_field(
564                                            "aabbCenter",
565                                        ),
566                                    );
567                                }
568                                m_aabbCenter = _serde::__private::Some(
569                                    match __A::next_value::<Vector4>(&mut __map) {
570                                        _serde::__private::Ok(__val) => __val,
571                                        _serde::__private::Err(__err) => {
572                                            return _serde::__private::Err(__err);
573                                        }
574                                    },
575                                );
576                            }
577                            __Field::m_numBitsForSubpartIndex => {
578                                #[cfg(
579                                    any(feature = "strict", feature = "ignore_duplicates")
580                                )]
581                                if _serde::__private::Option::is_some(
582                                    &m_numBitsForSubpartIndex,
583                                ) {
584                                    #[cfg(feature = "ignore_duplicates")]
585                                    {
586                                        __A::skip_value(&mut __map)?;
587                                        continue;
588                                    }
589                                    #[cfg(feature = "strict")]
590                                    return _serde::__private::Err(
591                                        <__A::Error as _serde::de::Error>::duplicate_field(
592                                            "numBitsForSubpartIndex",
593                                        ),
594                                    );
595                                }
596                                m_numBitsForSubpartIndex = _serde::__private::Some(
597                                    match __A::next_value::<i32>(&mut __map) {
598                                        _serde::__private::Ok(__val) => __val,
599                                        _serde::__private::Err(__err) => {
600                                            return _serde::__private::Err(__err);
601                                        }
602                                    },
603                                );
604                            }
605                            __Field::m_trianglesSubparts => {
606                                #[cfg(
607                                    any(feature = "strict", feature = "ignore_duplicates")
608                                )]
609                                if _serde::__private::Option::is_some(
610                                    &m_trianglesSubparts,
611                                ) {
612                                    #[cfg(feature = "ignore_duplicates")]
613                                    {
614                                        __A::skip_value(&mut __map)?;
615                                        continue;
616                                    }
617                                    #[cfg(feature = "strict")]
618                                    return _serde::__private::Err(
619                                        <__A::Error as _serde::de::Error>::duplicate_field(
620                                            "trianglesSubparts",
621                                        ),
622                                    );
623                                }
624                                m_trianglesSubparts = _serde::__private::Some(
625                                    match __A::next_value::<
626                                        Vec<hkpExtendedMeshShapeTrianglesSubpart>,
627                                    >(&mut __map) {
628                                        _serde::__private::Ok(__val) => __val,
629                                        _serde::__private::Err(__err) => {
630                                            return _serde::__private::Err(__err);
631                                        }
632                                    },
633                                );
634                            }
635                            __Field::m_shapesSubparts => {
636                                #[cfg(
637                                    any(feature = "strict", feature = "ignore_duplicates")
638                                )]
639                                if _serde::__private::Option::is_some(&m_shapesSubparts) {
640                                    #[cfg(feature = "ignore_duplicates")]
641                                    {
642                                        __A::skip_value(&mut __map)?;
643                                        continue;
644                                    }
645                                    #[cfg(feature = "strict")]
646                                    return _serde::__private::Err(
647                                        <__A::Error as _serde::de::Error>::duplicate_field(
648                                            "shapesSubparts",
649                                        ),
650                                    );
651                                }
652                                m_shapesSubparts = _serde::__private::Some(
653                                    match __A::next_value::<
654                                        Vec<hkpExtendedMeshShapeShapesSubpart>,
655                                    >(&mut __map) {
656                                        _serde::__private::Ok(__val) => __val,
657                                        _serde::__private::Err(__err) => {
658                                            return _serde::__private::Err(__err);
659                                        }
660                                    },
661                                );
662                            }
663                            __Field::m_weldingInfo => {
664                                #[cfg(
665                                    any(feature = "strict", feature = "ignore_duplicates")
666                                )]
667                                if _serde::__private::Option::is_some(&m_weldingInfo) {
668                                    #[cfg(feature = "ignore_duplicates")]
669                                    {
670                                        __A::skip_value(&mut __map)?;
671                                        continue;
672                                    }
673                                    #[cfg(feature = "strict")]
674                                    return _serde::__private::Err(
675                                        <__A::Error as _serde::de::Error>::duplicate_field(
676                                            "weldingInfo",
677                                        ),
678                                    );
679                                }
680                                m_weldingInfo = _serde::__private::Some(
681                                    match __A::next_value::<Vec<u16>>(&mut __map) {
682                                        _serde::__private::Ok(__val) => __val,
683                                        _serde::__private::Err(__err) => {
684                                            return _serde::__private::Err(__err);
685                                        }
686                                    },
687                                );
688                            }
689                            __Field::m_weldingType => {
690                                #[cfg(
691                                    any(feature = "strict", feature = "ignore_duplicates")
692                                )]
693                                if _serde::__private::Option::is_some(&m_weldingType) {
694                                    #[cfg(feature = "ignore_duplicates")]
695                                    {
696                                        __A::skip_value(&mut __map)?;
697                                        continue;
698                                    }
699                                    #[cfg(feature = "strict")]
700                                    return _serde::__private::Err(
701                                        <__A::Error as _serde::de::Error>::duplicate_field(
702                                            "weldingType",
703                                        ),
704                                    );
705                                }
706                                m_weldingType = _serde::__private::Some(
707                                    match __A::next_value::<WeldingType>(&mut __map) {
708                                        _serde::__private::Ok(__val) => __val,
709                                        _serde::__private::Err(__err) => {
710                                            return _serde::__private::Err(__err);
711                                        }
712                                    },
713                                );
714                            }
715                            __Field::m_defaultCollisionFilterInfo => {
716                                #[cfg(
717                                    any(feature = "strict", feature = "ignore_duplicates")
718                                )]
719                                if _serde::__private::Option::is_some(
720                                    &m_defaultCollisionFilterInfo,
721                                ) {
722                                    #[cfg(feature = "ignore_duplicates")]
723                                    {
724                                        __A::skip_value(&mut __map)?;
725                                        continue;
726                                    }
727                                    #[cfg(feature = "strict")]
728                                    return _serde::__private::Err(
729                                        <__A::Error as _serde::de::Error>::duplicate_field(
730                                            "defaultCollisionFilterInfo",
731                                        ),
732                                    );
733                                }
734                                m_defaultCollisionFilterInfo = _serde::__private::Some(
735                                    match __A::next_value::<u32>(&mut __map) {
736                                        _serde::__private::Ok(__val) => __val,
737                                        _serde::__private::Err(__err) => {
738                                            return _serde::__private::Err(__err);
739                                        }
740                                    },
741                                );
742                            }
743                            __Field::m_cachedNumChildShapes => {
744                                #[cfg(
745                                    any(feature = "strict", feature = "ignore_duplicates")
746                                )]
747                                if _serde::__private::Option::is_some(
748                                    &m_cachedNumChildShapes,
749                                ) {
750                                    #[cfg(feature = "ignore_duplicates")]
751                                    {
752                                        __A::skip_value(&mut __map)?;
753                                        continue;
754                                    }
755                                    #[cfg(feature = "strict")]
756                                    return _serde::__private::Err(
757                                        <__A::Error as _serde::de::Error>::duplicate_field(
758                                            "cachedNumChildShapes",
759                                        ),
760                                    );
761                                }
762                                m_cachedNumChildShapes = _serde::__private::Some(
763                                    match __A::next_value::<i32>(&mut __map) {
764                                        _serde::__private::Ok(__val) => __val,
765                                        _serde::__private::Err(__err) => {
766                                            return _serde::__private::Err(__err);
767                                        }
768                                    },
769                                );
770                            }
771                            __Field::m_triangleRadius => {
772                                #[cfg(
773                                    any(feature = "strict", feature = "ignore_duplicates")
774                                )]
775                                if _serde::__private::Option::is_some(&m_triangleRadius) {
776                                    #[cfg(feature = "ignore_duplicates")]
777                                    {
778                                        __A::skip_value(&mut __map)?;
779                                        continue;
780                                    }
781                                    #[cfg(feature = "strict")]
782                                    return _serde::__private::Err(
783                                        <__A::Error as _serde::de::Error>::duplicate_field(
784                                            "triangleRadius",
785                                        ),
786                                    );
787                                }
788                                m_triangleRadius = _serde::__private::Some(
789                                    match __A::next_value::<f32>(&mut __map) {
790                                        _serde::__private::Ok(__val) => __val,
791                                        _serde::__private::Err(__err) => {
792                                            return _serde::__private::Err(__err);
793                                        }
794                                    },
795                                );
796                            }
797                            __Field::m_meshstorage => {
798                                #[cfg(
799                                    any(feature = "strict", feature = "ignore_duplicates")
800                                )]
801                                if _serde::__private::Option::is_some(&m_meshstorage) {
802                                    #[cfg(feature = "ignore_duplicates")]
803                                    {
804                                        __A::skip_value(&mut __map)?;
805                                        continue;
806                                    }
807                                    #[cfg(feature = "strict")]
808                                    return _serde::__private::Err(
809                                        <__A::Error as _serde::de::Error>::duplicate_field(
810                                            "meshstorage",
811                                        ),
812                                    );
813                                }
814                                m_meshstorage = _serde::__private::Some(
815                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
816                                        _serde::__private::Ok(__val) => __val,
817                                        _serde::__private::Err(__err) => {
818                                            return _serde::__private::Err(__err);
819                                        }
820                                    },
821                                );
822                            }
823                            __Field::m_shapestorage => {
824                                #[cfg(
825                                    any(feature = "strict", feature = "ignore_duplicates")
826                                )]
827                                if _serde::__private::Option::is_some(&m_shapestorage) {
828                                    #[cfg(feature = "ignore_duplicates")]
829                                    {
830                                        __A::skip_value(&mut __map)?;
831                                        continue;
832                                    }
833                                    #[cfg(feature = "strict")]
834                                    return _serde::__private::Err(
835                                        <__A::Error as _serde::de::Error>::duplicate_field(
836                                            "shapestorage",
837                                        ),
838                                    );
839                                }
840                                m_shapestorage = _serde::__private::Some(
841                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
842                                        _serde::__private::Ok(__val) => __val,
843                                        _serde::__private::Err(__err) => {
844                                            return _serde::__private::Err(__err);
845                                        }
846                                    },
847                                );
848                            }
849                            _ => __A::skip_value(&mut __map)?,
850                        }
851                    }
852                    let m_userData = match m_userData {
853                        _serde::__private::Some(__field) => __field,
854                        _serde::__private::None => {
855                            #[cfg(feature = "strict")]
856                            return _serde::__private::Err(
857                                <__A::Error as _serde::de::Error>::missing_field("userData"),
858                            );
859                            #[cfg(not(feature = "strict"))] Default::default()
860                        }
861                    };
862                    let m_disableWelding = match m_disableWelding {
863                        _serde::__private::Some(__field) => __field,
864                        _serde::__private::None => {
865                            #[cfg(feature = "strict")]
866                            return _serde::__private::Err(
867                                <__A::Error as _serde::de::Error>::missing_field(
868                                    "disableWelding",
869                                ),
870                            );
871                            #[cfg(not(feature = "strict"))] Default::default()
872                        }
873                    };
874                    let m_collectionType = match m_collectionType {
875                        _serde::__private::Some(__field) => __field,
876                        _serde::__private::None => {
877                            #[cfg(feature = "strict")]
878                            return _serde::__private::Err(
879                                <__A::Error as _serde::de::Error>::missing_field(
880                                    "collectionType",
881                                ),
882                            );
883                            #[cfg(not(feature = "strict"))] Default::default()
884                        }
885                    };
886                    let m_embeddedTrianglesSubpart = match m_embeddedTrianglesSubpart {
887                        _serde::__private::Some(__field) => __field,
888                        _serde::__private::None => {
889                            #[cfg(feature = "strict")]
890                            return _serde::__private::Err(
891                                <__A::Error as _serde::de::Error>::missing_field(
892                                    "embeddedTrianglesSubpart",
893                                ),
894                            );
895                            #[cfg(not(feature = "strict"))] Default::default()
896                        }
897                    };
898                    let m_aabbHalfExtents = match m_aabbHalfExtents {
899                        _serde::__private::Some(__field) => __field,
900                        _serde::__private::None => {
901                            #[cfg(feature = "strict")]
902                            return _serde::__private::Err(
903                                <__A::Error as _serde::de::Error>::missing_field(
904                                    "aabbHalfExtents",
905                                ),
906                            );
907                            #[cfg(not(feature = "strict"))] Default::default()
908                        }
909                    };
910                    let m_aabbCenter = match m_aabbCenter {
911                        _serde::__private::Some(__field) => __field,
912                        _serde::__private::None => {
913                            #[cfg(feature = "strict")]
914                            return _serde::__private::Err(
915                                <__A::Error as _serde::de::Error>::missing_field(
916                                    "aabbCenter",
917                                ),
918                            );
919                            #[cfg(not(feature = "strict"))] Default::default()
920                        }
921                    };
922                    let m_numBitsForSubpartIndex = match m_numBitsForSubpartIndex {
923                        _serde::__private::Some(__field) => __field,
924                        _serde::__private::None => {
925                            #[cfg(feature = "strict")]
926                            return _serde::__private::Err(
927                                <__A::Error as _serde::de::Error>::missing_field(
928                                    "numBitsForSubpartIndex",
929                                ),
930                            );
931                            #[cfg(not(feature = "strict"))] Default::default()
932                        }
933                    };
934                    let m_trianglesSubparts = match m_trianglesSubparts {
935                        _serde::__private::Some(__field) => __field,
936                        _serde::__private::None => {
937                            #[cfg(feature = "strict")]
938                            return _serde::__private::Err(
939                                <__A::Error as _serde::de::Error>::missing_field(
940                                    "trianglesSubparts",
941                                ),
942                            );
943                            #[cfg(not(feature = "strict"))] Default::default()
944                        }
945                    };
946                    let m_shapesSubparts = match m_shapesSubparts {
947                        _serde::__private::Some(__field) => __field,
948                        _serde::__private::None => {
949                            #[cfg(feature = "strict")]
950                            return _serde::__private::Err(
951                                <__A::Error as _serde::de::Error>::missing_field(
952                                    "shapesSubparts",
953                                ),
954                            );
955                            #[cfg(not(feature = "strict"))] Default::default()
956                        }
957                    };
958                    let m_weldingInfo = match m_weldingInfo {
959                        _serde::__private::Some(__field) => __field,
960                        _serde::__private::None => {
961                            #[cfg(feature = "strict")]
962                            return _serde::__private::Err(
963                                <__A::Error as _serde::de::Error>::missing_field(
964                                    "weldingInfo",
965                                ),
966                            );
967                            #[cfg(not(feature = "strict"))] Default::default()
968                        }
969                    };
970                    let m_weldingType = match m_weldingType {
971                        _serde::__private::Some(__field) => __field,
972                        _serde::__private::None => {
973                            #[cfg(feature = "strict")]
974                            return _serde::__private::Err(
975                                <__A::Error as _serde::de::Error>::missing_field(
976                                    "weldingType",
977                                ),
978                            );
979                            #[cfg(not(feature = "strict"))] Default::default()
980                        }
981                    };
982                    let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
983                        _serde::__private::Some(__field) => __field,
984                        _serde::__private::None => {
985                            #[cfg(feature = "strict")]
986                            return _serde::__private::Err(
987                                <__A::Error as _serde::de::Error>::missing_field(
988                                    "defaultCollisionFilterInfo",
989                                ),
990                            );
991                            #[cfg(not(feature = "strict"))] Default::default()
992                        }
993                    };
994                    let m_cachedNumChildShapes = match m_cachedNumChildShapes {
995                        _serde::__private::Some(__field) => __field,
996                        _serde::__private::None => {
997                            #[cfg(feature = "strict")]
998                            return _serde::__private::Err(
999                                <__A::Error as _serde::de::Error>::missing_field(
1000                                    "cachedNumChildShapes",
1001                                ),
1002                            );
1003                            #[cfg(not(feature = "strict"))] Default::default()
1004                        }
1005                    };
1006                    let m_triangleRadius = match m_triangleRadius {
1007                        _serde::__private::Some(__field) => __field,
1008                        _serde::__private::None => {
1009                            #[cfg(feature = "strict")]
1010                            return _serde::__private::Err(
1011                                <__A::Error as _serde::de::Error>::missing_field(
1012                                    "triangleRadius",
1013                                ),
1014                            );
1015                            #[cfg(not(feature = "strict"))] Default::default()
1016                        }
1017                    };
1018                    let m_meshstorage = match m_meshstorage {
1019                        _serde::__private::Some(__field) => __field,
1020                        _serde::__private::None => {
1021                            #[cfg(feature = "strict")]
1022                            return _serde::__private::Err(
1023                                <__A::Error as _serde::de::Error>::missing_field(
1024                                    "meshstorage",
1025                                ),
1026                            );
1027                            #[cfg(not(feature = "strict"))] Default::default()
1028                        }
1029                    };
1030                    let m_shapestorage = match m_shapestorage {
1031                        _serde::__private::Some(__field) => __field,
1032                        _serde::__private::None => {
1033                            #[cfg(feature = "strict")]
1034                            return _serde::__private::Err(
1035                                <__A::Error as _serde::de::Error>::missing_field(
1036                                    "shapestorage",
1037                                ),
1038                            );
1039                            #[cfg(not(feature = "strict"))] Default::default()
1040                        }
1041                    };
1042                    let __ptr = None;
1043                    let parent = hkBaseObject { __ptr };
1044                    let parent = hkReferencedObject {
1045                        __ptr,
1046                        parent,
1047                        ..Default::default()
1048                    };
1049                    let parent = hkpShape {
1050                        __ptr,
1051                        parent,
1052                        m_userData,
1053                        ..Default::default()
1054                    };
1055                    let parent = hkpShapeCollection {
1056                        __ptr,
1057                        parent,
1058                        m_disableWelding,
1059                        m_collectionType,
1060                    };
1061                    let parent = hkpExtendedMeshShape {
1062                        __ptr,
1063                        parent,
1064                        m_embeddedTrianglesSubpart,
1065                        m_aabbHalfExtents,
1066                        m_aabbCenter,
1067                        m_numBitsForSubpartIndex,
1068                        m_trianglesSubparts,
1069                        m_shapesSubparts,
1070                        m_weldingInfo,
1071                        m_weldingType,
1072                        m_defaultCollisionFilterInfo,
1073                        m_cachedNumChildShapes,
1074                        m_triangleRadius,
1075                        ..Default::default()
1076                    };
1077                    let __ptr = __A::class_ptr(&mut __map);
1078                    _serde::__private::Ok(hkpStorageExtendedMeshShape {
1079                        __ptr,
1080                        parent,
1081                        m_meshstorage,
1082                        m_shapestorage,
1083                    })
1084                }
1085            }
1086            const FIELDS: &[&str] = &["meshstorage", "shapestorage"];
1087            _serde::Deserializer::deserialize_struct(
1088                deserializer,
1089                "hkpStorageExtendedMeshShape",
1090                FIELDS,
1091                __hkpStorageExtendedMeshShapeVisitor {
1092                    marker: _serde::__private::PhantomData::<
1093                        hkpStorageExtendedMeshShape,
1094                    >,
1095                    lifetime: _serde::__private::PhantomData,
1096                },
1097            )
1098        }
1099    }
1100};