havok_classes/generated/
hkpStorageExtendedMeshShapeMeshSubpartStorage_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpStorageExtendedMeshShapeMeshSubpartStorage`
5/// - version: `3`
6/// - signature: `0x5aad4de6`
7/// - size: `104`(x86)/`144`(x86_64)
8/// -  vtable: `true`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkpStorageExtendedMeshShapeMeshSubpartStorage<'a> {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `vertices`(ctype: `hkArray<hkVector4>`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "vertices"))]
35    #[cfg_attr(feature = "serde", serde(rename = "vertices"))]
36    pub m_vertices: Vec<Vector4>,
37    /// # C++ Info
38    /// - name: `indices8`(ctype: `hkArray<hkUint8>`)
39    /// - offset: ` 20`(x86)/` 32`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "indices8"))]
42    #[cfg_attr(feature = "serde", serde(rename = "indices8"))]
43    pub m_indices8: Vec<u8>,
44    /// # C++ Info
45    /// - name: `indices16`(ctype: `hkArray<hkUint16>`)
46    /// - offset: ` 32`(x86)/` 48`(x86_64)
47    /// - type_size: ` 12`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "indices16"))]
49    #[cfg_attr(feature = "serde", serde(rename = "indices16"))]
50    pub m_indices16: Vec<u16>,
51    /// # C++ Info
52    /// - name: `indices32`(ctype: `hkArray<hkUint32>`)
53    /// - offset: ` 44`(x86)/` 64`(x86_64)
54    /// - type_size: ` 12`(x86)/` 16`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "indices32"))]
56    #[cfg_attr(feature = "serde", serde(rename = "indices32"))]
57    pub m_indices32: Vec<u32>,
58    /// # C++ Info
59    /// - name: `materialIndices`(ctype: `hkArray<hkUint8>`)
60    /// - offset: ` 56`(x86)/` 80`(x86_64)
61    /// - type_size: ` 12`(x86)/` 16`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndices"))]
63    #[cfg_attr(feature = "serde", serde(rename = "materialIndices"))]
64    pub m_materialIndices: Vec<u8>,
65    /// # C++ Info
66    /// - name: `materials`(ctype: `hkArray<struct hkpStorageExtendedMeshShapeMaterial>`)
67    /// - offset: ` 68`(x86)/` 96`(x86_64)
68    /// - type_size: ` 12`(x86)/` 16`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "materials"))]
70    #[cfg_attr(feature = "serde", serde(rename = "materials"))]
71    pub m_materials: Vec<hkpStorageExtendedMeshShapeMaterial>,
72    /// # C++ Info
73    /// - name: `namedMaterials`(ctype: `hkArray<struct hkpNamedMeshMaterial>`)
74    /// - offset: ` 80`(x86)/`112`(x86_64)
75    /// - type_size: ` 12`(x86)/` 16`(x86_64)
76    #[cfg_attr(feature = "serde", serde(borrow))]
77    #[cfg_attr(feature = "json_schema", schemars(rename = "namedMaterials"))]
78    #[cfg_attr(feature = "serde", serde(rename = "namedMaterials"))]
79    pub m_namedMaterials: Vec<hkpNamedMeshMaterial<'a>>,
80    /// # C++ Info
81    /// - name: `materialIndices16`(ctype: `hkArray<hkUint16>`)
82    /// - offset: ` 92`(x86)/`128`(x86_64)
83    /// - type_size: ` 12`(x86)/` 16`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndices16"))]
85    #[cfg_attr(feature = "serde", serde(rename = "materialIndices16"))]
86    pub m_materialIndices16: Vec<u16>,
87}
88const _: () = {
89    use havok_serde as _serde;
90    impl<'a> _serde::HavokClass for hkpStorageExtendedMeshShapeMeshSubpartStorage<'a> {
91        #[inline]
92        fn name(&self) -> &'static str {
93            "hkpStorageExtendedMeshShapeMeshSubpartStorage"
94        }
95        #[inline]
96        fn signature(&self) -> _serde::__private::Signature {
97            _serde::__private::Signature::new(0x5aad4de6)
98        }
99        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
100        fn deps_indexes(&self) -> Vec<usize> {
101            let mut v = Vec::new();
102            v.extend(
103                self
104                    .m_materials
105                    .iter()
106                    .flat_map(|class| class.deps_indexes())
107                    .collect::<Vec<usize>>(),
108            );
109            v.extend(
110                self
111                    .m_namedMaterials
112                    .iter()
113                    .flat_map(|class| class.deps_indexes())
114                    .collect::<Vec<usize>>(),
115            );
116            v
117        }
118    }
119    impl<'a> _serde::Serialize for hkpStorageExtendedMeshShapeMeshSubpartStorage<'a> {
120        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
121        where
122            S: _serde::ser::Serializer,
123        {
124            let class_meta = self
125                .__ptr
126                .map(|name| (name, _serde::__private::Signature::new(0x5aad4de6)));
127            let mut serializer = __serializer
128                .serialize_struct(
129                    "hkpStorageExtendedMeshShapeMeshSubpartStorage",
130                    class_meta,
131                    (104u64, 144u64),
132                )?;
133            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
134            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
135            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
136            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
137            serializer
138                .serialize_array_field("vertices", &self.m_vertices, TypeSize::NonPtr)?;
139            serializer
140                .serialize_array_field("indices8", &self.m_indices8, TypeSize::NonPtr)?;
141            serializer
142                .serialize_array_field(
143                    "indices16",
144                    &self.m_indices16,
145                    TypeSize::NonPtr,
146                )?;
147            serializer
148                .serialize_array_field(
149                    "indices32",
150                    &self.m_indices32,
151                    TypeSize::NonPtr,
152                )?;
153            serializer
154                .serialize_array_field(
155                    "materialIndices",
156                    &self.m_materialIndices,
157                    TypeSize::NonPtr,
158                )?;
159            serializer
160                .serialize_array_field(
161                    "materials",
162                    &self.m_materials,
163                    TypeSize::Struct {
164                        size_x86: 12u64,
165                        size_x86_64: 16u64,
166                    },
167                )?;
168            serializer
169                .serialize_array_field(
170                    "namedMaterials",
171                    &self.m_namedMaterials,
172                    TypeSize::Struct {
173                        size_x86: 8u64,
174                        size_x86_64: 16u64,
175                    },
176                )?;
177            serializer
178                .serialize_array_field(
179                    "materialIndices16",
180                    &self.m_materialIndices16,
181                    TypeSize::NonPtr,
182                )?;
183            serializer.end()
184        }
185    }
186};
187#[doc(hidden)]
188#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
189const _: () = {
190    use havok_serde as _serde;
191    #[automatically_derived]
192    impl<'de> _serde::Deserialize<'de>
193    for hkpStorageExtendedMeshShapeMeshSubpartStorage<'de> {
194        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
195        where
196            __D: _serde::Deserializer<'de>,
197        {
198            #[allow(non_camel_case_types)]
199            enum __Field {
200                m_vertices,
201                m_indices8,
202                m_indices16,
203                m_indices32,
204                m_materialIndices,
205                m_materials,
206                m_namedMaterials,
207                m_materialIndices16,
208                __ignore,
209            }
210            struct __FieldVisitor;
211            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
212                type Value = __Field;
213                fn expecting(
214                    &self,
215                    __formatter: &mut core::fmt::Formatter,
216                ) -> core::fmt::Result {
217                    core::fmt::Formatter::write_str(__formatter, "field identifier")
218                }
219                /// Intended for use in XML.
220                #[allow(clippy::match_single_binding)]
221                #[allow(clippy::reversed_empty_ranges)]
222                #[allow(clippy::single_match)]
223                fn visit_key<__E>(
224                    self,
225                    __value: &str,
226                ) -> core::result::Result<Self::Value, __E>
227                where
228                    __E: _serde::de::Error,
229                {
230                    match __value {
231                        "vertices" => Ok(__Field::m_vertices),
232                        "indices8" => Ok(__Field::m_indices8),
233                        "indices16" => Ok(__Field::m_indices16),
234                        "indices32" => Ok(__Field::m_indices32),
235                        "materialIndices" => Ok(__Field::m_materialIndices),
236                        "materials" => Ok(__Field::m_materials),
237                        "namedMaterials" => Ok(__Field::m_namedMaterials),
238                        "materialIndices16" => Ok(__Field::m_materialIndices16),
239                        _ => Ok(__Field::__ignore),
240                    }
241                }
242            }
243            impl<'de> _serde::Deserialize<'de> for __Field {
244                #[inline]
245                fn deserialize<__D>(
246                    __deserializer: __D,
247                ) -> core::result::Result<Self, __D::Error>
248                where
249                    __D: _serde::Deserializer<'de>,
250                {
251                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
252                }
253            }
254            struct __hkpStorageExtendedMeshShapeMeshSubpartStorageVisitor<'de> {
255                marker: _serde::__private::PhantomData<
256                    hkpStorageExtendedMeshShapeMeshSubpartStorage<'de>,
257                >,
258                lifetime: _serde::__private::PhantomData<&'de ()>,
259            }
260            #[allow(clippy::match_single_binding)]
261            #[allow(clippy::reversed_empty_ranges)]
262            #[allow(clippy::single_match)]
263            impl<'de> _serde::de::Visitor<'de>
264            for __hkpStorageExtendedMeshShapeMeshSubpartStorageVisitor<'de> {
265                type Value = hkpStorageExtendedMeshShapeMeshSubpartStorage<'de>;
266                fn expecting(
267                    &self,
268                    __formatter: &mut core::fmt::Formatter,
269                ) -> core::fmt::Result {
270                    core::fmt::Formatter::write_str(
271                        __formatter,
272                        "struct hkpStorageExtendedMeshShapeMeshSubpartStorage",
273                    )
274                }
275                fn visit_struct_for_bytes<__A>(
276                    self,
277                    mut __map: __A,
278                ) -> _serde::__private::Result<Self::Value, __A::Error>
279                where
280                    __A: _serde::de::MapAccess<'de>,
281                {
282                    let __ptr = __A::class_ptr(&mut __map);
283                    let parent = __A::parent_value(&mut __map)?;
284                    let mut m_vertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
285                    let mut m_indices8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
286                    let mut m_indices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
287                    let mut m_indices32: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
288                    let mut m_materialIndices: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
289                    let mut m_materials: _serde::__private::Option<
290                        Vec<hkpStorageExtendedMeshShapeMaterial>,
291                    > = _serde::__private::None;
292                    let mut m_namedMaterials: _serde::__private::Option<
293                        Vec<hkpNamedMeshMaterial<'de>>,
294                    > = _serde::__private::None;
295                    let mut m_materialIndices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
296                    for i in 0..8usize {
297                        match i {
298                            0usize => {
299                                if _serde::__private::Option::is_some(&m_vertices) {
300                                    return _serde::__private::Err(
301                                        <__A::Error as _serde::de::Error>::duplicate_field(
302                                            "vertices",
303                                        ),
304                                    );
305                                }
306                                m_vertices = _serde::__private::Some(
307                                    match __A::next_value::<Vec<Vector4>>(&mut __map) {
308                                        _serde::__private::Ok(__val) => __val,
309                                        _serde::__private::Err(__err) => {
310                                            return _serde::__private::Err(__err);
311                                        }
312                                    },
313                                );
314                            }
315                            1usize => {
316                                if _serde::__private::Option::is_some(&m_indices8) {
317                                    return _serde::__private::Err(
318                                        <__A::Error as _serde::de::Error>::duplicate_field(
319                                            "indices8",
320                                        ),
321                                    );
322                                }
323                                m_indices8 = _serde::__private::Some(
324                                    match __A::next_value::<Vec<u8>>(&mut __map) {
325                                        _serde::__private::Ok(__val) => __val,
326                                        _serde::__private::Err(__err) => {
327                                            return _serde::__private::Err(__err);
328                                        }
329                                    },
330                                );
331                            }
332                            2usize => {
333                                if _serde::__private::Option::is_some(&m_indices16) {
334                                    return _serde::__private::Err(
335                                        <__A::Error as _serde::de::Error>::duplicate_field(
336                                            "indices16",
337                                        ),
338                                    );
339                                }
340                                m_indices16 = _serde::__private::Some(
341                                    match __A::next_value::<Vec<u16>>(&mut __map) {
342                                        _serde::__private::Ok(__val) => __val,
343                                        _serde::__private::Err(__err) => {
344                                            return _serde::__private::Err(__err);
345                                        }
346                                    },
347                                );
348                            }
349                            3usize => {
350                                if _serde::__private::Option::is_some(&m_indices32) {
351                                    return _serde::__private::Err(
352                                        <__A::Error as _serde::de::Error>::duplicate_field(
353                                            "indices32",
354                                        ),
355                                    );
356                                }
357                                m_indices32 = _serde::__private::Some(
358                                    match __A::next_value::<Vec<u32>>(&mut __map) {
359                                        _serde::__private::Ok(__val) => __val,
360                                        _serde::__private::Err(__err) => {
361                                            return _serde::__private::Err(__err);
362                                        }
363                                    },
364                                );
365                            }
366                            4usize => {
367                                if _serde::__private::Option::is_some(&m_materialIndices) {
368                                    return _serde::__private::Err(
369                                        <__A::Error as _serde::de::Error>::duplicate_field(
370                                            "materialIndices",
371                                        ),
372                                    );
373                                }
374                                m_materialIndices = _serde::__private::Some(
375                                    match __A::next_value::<Vec<u8>>(&mut __map) {
376                                        _serde::__private::Ok(__val) => __val,
377                                        _serde::__private::Err(__err) => {
378                                            return _serde::__private::Err(__err);
379                                        }
380                                    },
381                                );
382                            }
383                            5usize => {
384                                if _serde::__private::Option::is_some(&m_materials) {
385                                    return _serde::__private::Err(
386                                        <__A::Error as _serde::de::Error>::duplicate_field(
387                                            "materials",
388                                        ),
389                                    );
390                                }
391                                m_materials = _serde::__private::Some(
392                                    match __A::next_value::<
393                                        Vec<hkpStorageExtendedMeshShapeMaterial>,
394                                    >(&mut __map) {
395                                        _serde::__private::Ok(__val) => __val,
396                                        _serde::__private::Err(__err) => {
397                                            return _serde::__private::Err(__err);
398                                        }
399                                    },
400                                );
401                            }
402                            6usize => {
403                                if _serde::__private::Option::is_some(&m_namedMaterials) {
404                                    return _serde::__private::Err(
405                                        <__A::Error as _serde::de::Error>::duplicate_field(
406                                            "namedMaterials",
407                                        ),
408                                    );
409                                }
410                                m_namedMaterials = _serde::__private::Some(
411                                    match __A::next_value::<
412                                        Vec<hkpNamedMeshMaterial<'de>>,
413                                    >(&mut __map) {
414                                        _serde::__private::Ok(__val) => __val,
415                                        _serde::__private::Err(__err) => {
416                                            return _serde::__private::Err(__err);
417                                        }
418                                    },
419                                );
420                            }
421                            7usize => {
422                                if _serde::__private::Option::is_some(
423                                    &m_materialIndices16,
424                                ) {
425                                    return _serde::__private::Err(
426                                        <__A::Error as _serde::de::Error>::duplicate_field(
427                                            "materialIndices16",
428                                        ),
429                                    );
430                                }
431                                m_materialIndices16 = _serde::__private::Some(
432                                    match __A::next_value::<Vec<u16>>(&mut __map) {
433                                        _serde::__private::Ok(__val) => __val,
434                                        _serde::__private::Err(__err) => {
435                                            return _serde::__private::Err(__err);
436                                        }
437                                    },
438                                );
439                            }
440                            _ => {}
441                        }
442                    }
443                    let m_vertices = match m_vertices {
444                        _serde::__private::Some(__field) => __field,
445                        _serde::__private::None => {
446                            return _serde::__private::Err(
447                                <__A::Error as _serde::de::Error>::missing_field("vertices"),
448                            );
449                        }
450                    };
451                    let m_indices8 = match m_indices8 {
452                        _serde::__private::Some(__field) => __field,
453                        _serde::__private::None => {
454                            return _serde::__private::Err(
455                                <__A::Error as _serde::de::Error>::missing_field("indices8"),
456                            );
457                        }
458                    };
459                    let m_indices16 = match m_indices16 {
460                        _serde::__private::Some(__field) => __field,
461                        _serde::__private::None => {
462                            return _serde::__private::Err(
463                                <__A::Error as _serde::de::Error>::missing_field(
464                                    "indices16",
465                                ),
466                            );
467                        }
468                    };
469                    let m_indices32 = match m_indices32 {
470                        _serde::__private::Some(__field) => __field,
471                        _serde::__private::None => {
472                            return _serde::__private::Err(
473                                <__A::Error as _serde::de::Error>::missing_field(
474                                    "indices32",
475                                ),
476                            );
477                        }
478                    };
479                    let m_materialIndices = match m_materialIndices {
480                        _serde::__private::Some(__field) => __field,
481                        _serde::__private::None => {
482                            return _serde::__private::Err(
483                                <__A::Error as _serde::de::Error>::missing_field(
484                                    "materialIndices",
485                                ),
486                            );
487                        }
488                    };
489                    let m_materials = match m_materials {
490                        _serde::__private::Some(__field) => __field,
491                        _serde::__private::None => {
492                            return _serde::__private::Err(
493                                <__A::Error as _serde::de::Error>::missing_field(
494                                    "materials",
495                                ),
496                            );
497                        }
498                    };
499                    let m_namedMaterials = match m_namedMaterials {
500                        _serde::__private::Some(__field) => __field,
501                        _serde::__private::None => {
502                            return _serde::__private::Err(
503                                <__A::Error as _serde::de::Error>::missing_field(
504                                    "namedMaterials",
505                                ),
506                            );
507                        }
508                    };
509                    let m_materialIndices16 = match m_materialIndices16 {
510                        _serde::__private::Some(__field) => __field,
511                        _serde::__private::None => {
512                            return _serde::__private::Err(
513                                <__A::Error as _serde::de::Error>::missing_field(
514                                    "materialIndices16",
515                                ),
516                            );
517                        }
518                    };
519                    _serde::__private::Ok(hkpStorageExtendedMeshShapeMeshSubpartStorage {
520                        __ptr,
521                        parent,
522                        m_vertices,
523                        m_indices8,
524                        m_indices16,
525                        m_indices32,
526                        m_materialIndices,
527                        m_materials,
528                        m_namedMaterials,
529                        m_materialIndices16,
530                    })
531                }
532                #[allow(clippy::manual_unwrap_or_default)]
533                fn visit_struct<__A>(
534                    self,
535                    mut __map: __A,
536                ) -> _serde::__private::Result<Self::Value, __A::Error>
537                where
538                    __A: _serde::de::MapAccess<'de>,
539                {
540                    let mut m_vertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
541                    let mut m_indices8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
542                    let mut m_indices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
543                    let mut m_indices32: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
544                    let mut m_materialIndices: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
545                    let mut m_materials: _serde::__private::Option<
546                        Vec<hkpStorageExtendedMeshShapeMaterial>,
547                    > = _serde::__private::None;
548                    let mut m_namedMaterials: _serde::__private::Option<
549                        Vec<hkpNamedMeshMaterial<'de>>,
550                    > = _serde::__private::None;
551                    let mut m_materialIndices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
552                    while let _serde::__private::Some(__key) = {
553                        __A::next_key::<__Field>(&mut __map)?
554                    } {
555                        match __key {
556                            __Field::m_vertices => {
557                                #[cfg(
558                                    any(feature = "strict", feature = "ignore_duplicates")
559                                )]
560                                if _serde::__private::Option::is_some(&m_vertices) {
561                                    #[cfg(feature = "ignore_duplicates")]
562                                    {
563                                        __A::skip_value(&mut __map)?;
564                                        continue;
565                                    }
566                                    #[cfg(feature = "strict")]
567                                    return _serde::__private::Err(
568                                        <__A::Error as _serde::de::Error>::duplicate_field(
569                                            "vertices",
570                                        ),
571                                    );
572                                }
573                                m_vertices = _serde::__private::Some(
574                                    match __A::next_value::<Vec<Vector4>>(&mut __map) {
575                                        _serde::__private::Ok(__val) => __val,
576                                        _serde::__private::Err(__err) => {
577                                            return _serde::__private::Err(__err);
578                                        }
579                                    },
580                                );
581                            }
582                            __Field::m_indices8 => {
583                                #[cfg(
584                                    any(feature = "strict", feature = "ignore_duplicates")
585                                )]
586                                if _serde::__private::Option::is_some(&m_indices8) {
587                                    #[cfg(feature = "ignore_duplicates")]
588                                    {
589                                        __A::skip_value(&mut __map)?;
590                                        continue;
591                                    }
592                                    #[cfg(feature = "strict")]
593                                    return _serde::__private::Err(
594                                        <__A::Error as _serde::de::Error>::duplicate_field(
595                                            "indices8",
596                                        ),
597                                    );
598                                }
599                                m_indices8 = _serde::__private::Some(
600                                    match __A::next_value::<Vec<u8>>(&mut __map) {
601                                        _serde::__private::Ok(__val) => __val,
602                                        _serde::__private::Err(__err) => {
603                                            return _serde::__private::Err(__err);
604                                        }
605                                    },
606                                );
607                            }
608                            __Field::m_indices16 => {
609                                #[cfg(
610                                    any(feature = "strict", feature = "ignore_duplicates")
611                                )]
612                                if _serde::__private::Option::is_some(&m_indices16) {
613                                    #[cfg(feature = "ignore_duplicates")]
614                                    {
615                                        __A::skip_value(&mut __map)?;
616                                        continue;
617                                    }
618                                    #[cfg(feature = "strict")]
619                                    return _serde::__private::Err(
620                                        <__A::Error as _serde::de::Error>::duplicate_field(
621                                            "indices16",
622                                        ),
623                                    );
624                                }
625                                m_indices16 = _serde::__private::Some(
626                                    match __A::next_value::<Vec<u16>>(&mut __map) {
627                                        _serde::__private::Ok(__val) => __val,
628                                        _serde::__private::Err(__err) => {
629                                            return _serde::__private::Err(__err);
630                                        }
631                                    },
632                                );
633                            }
634                            __Field::m_indices32 => {
635                                #[cfg(
636                                    any(feature = "strict", feature = "ignore_duplicates")
637                                )]
638                                if _serde::__private::Option::is_some(&m_indices32) {
639                                    #[cfg(feature = "ignore_duplicates")]
640                                    {
641                                        __A::skip_value(&mut __map)?;
642                                        continue;
643                                    }
644                                    #[cfg(feature = "strict")]
645                                    return _serde::__private::Err(
646                                        <__A::Error as _serde::de::Error>::duplicate_field(
647                                            "indices32",
648                                        ),
649                                    );
650                                }
651                                m_indices32 = _serde::__private::Some(
652                                    match __A::next_value::<Vec<u32>>(&mut __map) {
653                                        _serde::__private::Ok(__val) => __val,
654                                        _serde::__private::Err(__err) => {
655                                            return _serde::__private::Err(__err);
656                                        }
657                                    },
658                                );
659                            }
660                            __Field::m_materialIndices => {
661                                #[cfg(
662                                    any(feature = "strict", feature = "ignore_duplicates")
663                                )]
664                                if _serde::__private::Option::is_some(&m_materialIndices) {
665                                    #[cfg(feature = "ignore_duplicates")]
666                                    {
667                                        __A::skip_value(&mut __map)?;
668                                        continue;
669                                    }
670                                    #[cfg(feature = "strict")]
671                                    return _serde::__private::Err(
672                                        <__A::Error as _serde::de::Error>::duplicate_field(
673                                            "materialIndices",
674                                        ),
675                                    );
676                                }
677                                m_materialIndices = _serde::__private::Some(
678                                    match __A::next_value::<Vec<u8>>(&mut __map) {
679                                        _serde::__private::Ok(__val) => __val,
680                                        _serde::__private::Err(__err) => {
681                                            return _serde::__private::Err(__err);
682                                        }
683                                    },
684                                );
685                            }
686                            __Field::m_materials => {
687                                #[cfg(
688                                    any(feature = "strict", feature = "ignore_duplicates")
689                                )]
690                                if _serde::__private::Option::is_some(&m_materials) {
691                                    #[cfg(feature = "ignore_duplicates")]
692                                    {
693                                        __A::skip_value(&mut __map)?;
694                                        continue;
695                                    }
696                                    #[cfg(feature = "strict")]
697                                    return _serde::__private::Err(
698                                        <__A::Error as _serde::de::Error>::duplicate_field(
699                                            "materials",
700                                        ),
701                                    );
702                                }
703                                m_materials = _serde::__private::Some(
704                                    match __A::next_value::<
705                                        Vec<hkpStorageExtendedMeshShapeMaterial>,
706                                    >(&mut __map) {
707                                        _serde::__private::Ok(__val) => __val,
708                                        _serde::__private::Err(__err) => {
709                                            return _serde::__private::Err(__err);
710                                        }
711                                    },
712                                );
713                            }
714                            __Field::m_namedMaterials => {
715                                #[cfg(
716                                    any(feature = "strict", feature = "ignore_duplicates")
717                                )]
718                                if _serde::__private::Option::is_some(&m_namedMaterials) {
719                                    #[cfg(feature = "ignore_duplicates")]
720                                    {
721                                        __A::skip_value(&mut __map)?;
722                                        continue;
723                                    }
724                                    #[cfg(feature = "strict")]
725                                    return _serde::__private::Err(
726                                        <__A::Error as _serde::de::Error>::duplicate_field(
727                                            "namedMaterials",
728                                        ),
729                                    );
730                                }
731                                m_namedMaterials = _serde::__private::Some(
732                                    match __A::next_value::<
733                                        Vec<hkpNamedMeshMaterial<'de>>,
734                                    >(&mut __map) {
735                                        _serde::__private::Ok(__val) => __val,
736                                        _serde::__private::Err(__err) => {
737                                            return _serde::__private::Err(__err);
738                                        }
739                                    },
740                                );
741                            }
742                            __Field::m_materialIndices16 => {
743                                #[cfg(
744                                    any(feature = "strict", feature = "ignore_duplicates")
745                                )]
746                                if _serde::__private::Option::is_some(
747                                    &m_materialIndices16,
748                                ) {
749                                    #[cfg(feature = "ignore_duplicates")]
750                                    {
751                                        __A::skip_value(&mut __map)?;
752                                        continue;
753                                    }
754                                    #[cfg(feature = "strict")]
755                                    return _serde::__private::Err(
756                                        <__A::Error as _serde::de::Error>::duplicate_field(
757                                            "materialIndices16",
758                                        ),
759                                    );
760                                }
761                                m_materialIndices16 = _serde::__private::Some(
762                                    match __A::next_value::<Vec<u16>>(&mut __map) {
763                                        _serde::__private::Ok(__val) => __val,
764                                        _serde::__private::Err(__err) => {
765                                            return _serde::__private::Err(__err);
766                                        }
767                                    },
768                                );
769                            }
770                            _ => __A::skip_value(&mut __map)?,
771                        }
772                    }
773                    let m_vertices = match m_vertices {
774                        _serde::__private::Some(__field) => __field,
775                        _serde::__private::None => {
776                            #[cfg(feature = "strict")]
777                            return _serde::__private::Err(
778                                <__A::Error as _serde::de::Error>::missing_field("vertices"),
779                            );
780                            #[cfg(not(feature = "strict"))] Default::default()
781                        }
782                    };
783                    let m_indices8 = match m_indices8 {
784                        _serde::__private::Some(__field) => __field,
785                        _serde::__private::None => {
786                            #[cfg(feature = "strict")]
787                            return _serde::__private::Err(
788                                <__A::Error as _serde::de::Error>::missing_field("indices8"),
789                            );
790                            #[cfg(not(feature = "strict"))] Default::default()
791                        }
792                    };
793                    let m_indices16 = match m_indices16 {
794                        _serde::__private::Some(__field) => __field,
795                        _serde::__private::None => {
796                            #[cfg(feature = "strict")]
797                            return _serde::__private::Err(
798                                <__A::Error as _serde::de::Error>::missing_field(
799                                    "indices16",
800                                ),
801                            );
802                            #[cfg(not(feature = "strict"))] Default::default()
803                        }
804                    };
805                    let m_indices32 = match m_indices32 {
806                        _serde::__private::Some(__field) => __field,
807                        _serde::__private::None => {
808                            #[cfg(feature = "strict")]
809                            return _serde::__private::Err(
810                                <__A::Error as _serde::de::Error>::missing_field(
811                                    "indices32",
812                                ),
813                            );
814                            #[cfg(not(feature = "strict"))] Default::default()
815                        }
816                    };
817                    let m_materialIndices = match m_materialIndices {
818                        _serde::__private::Some(__field) => __field,
819                        _serde::__private::None => {
820                            #[cfg(feature = "strict")]
821                            return _serde::__private::Err(
822                                <__A::Error as _serde::de::Error>::missing_field(
823                                    "materialIndices",
824                                ),
825                            );
826                            #[cfg(not(feature = "strict"))] Default::default()
827                        }
828                    };
829                    let m_materials = match m_materials {
830                        _serde::__private::Some(__field) => __field,
831                        _serde::__private::None => {
832                            #[cfg(feature = "strict")]
833                            return _serde::__private::Err(
834                                <__A::Error as _serde::de::Error>::missing_field(
835                                    "materials",
836                                ),
837                            );
838                            #[cfg(not(feature = "strict"))] Default::default()
839                        }
840                    };
841                    let m_namedMaterials = match m_namedMaterials {
842                        _serde::__private::Some(__field) => __field,
843                        _serde::__private::None => {
844                            #[cfg(feature = "strict")]
845                            return _serde::__private::Err(
846                                <__A::Error as _serde::de::Error>::missing_field(
847                                    "namedMaterials",
848                                ),
849                            );
850                            #[cfg(not(feature = "strict"))] Default::default()
851                        }
852                    };
853                    let m_materialIndices16 = match m_materialIndices16 {
854                        _serde::__private::Some(__field) => __field,
855                        _serde::__private::None => {
856                            #[cfg(feature = "strict")]
857                            return _serde::__private::Err(
858                                <__A::Error as _serde::de::Error>::missing_field(
859                                    "materialIndices16",
860                                ),
861                            );
862                            #[cfg(not(feature = "strict"))] Default::default()
863                        }
864                    };
865                    let __ptr = None;
866                    let parent = hkBaseObject { __ptr };
867                    let parent = hkReferencedObject {
868                        __ptr,
869                        parent,
870                        ..Default::default()
871                    };
872                    let __ptr = __A::class_ptr(&mut __map);
873                    _serde::__private::Ok(hkpStorageExtendedMeshShapeMeshSubpartStorage {
874                        __ptr,
875                        parent,
876                        m_vertices,
877                        m_indices8,
878                        m_indices16,
879                        m_indices32,
880                        m_materialIndices,
881                        m_materials,
882                        m_namedMaterials,
883                        m_materialIndices16,
884                    })
885                }
886            }
887            const FIELDS: &[&str] = &[
888                "vertices",
889                "indices8",
890                "indices16",
891                "indices32",
892                "materialIndices",
893                "materials",
894                "namedMaterials",
895                "materialIndices16",
896            ];
897            _serde::Deserializer::deserialize_struct(
898                deserializer,
899                "hkpStorageExtendedMeshShapeMeshSubpartStorage",
900                FIELDS,
901                __hkpStorageExtendedMeshShapeMeshSubpartStorageVisitor {
902                    marker: _serde::__private::PhantomData::<
903                        hkpStorageExtendedMeshShapeMeshSubpartStorage,
904                    >,
905                    lifetime: _serde::__private::PhantomData,
906                },
907            )
908        }
909    }
910};