havok_classes/generated/
hkpExtendedMeshShapeSubpart_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpExtendedMeshShapeSubpart`
5/// - version: `2`
6/// - signature: `0xf4608207`
7/// - size: ` 20`(x86)/` 40`(x86_64)
8/// -  vtable: `false`
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 hkpExtendedMeshShapeSubpart {
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    /// # C++ Info
27    /// - name: `type`(ctype: `enum SubpartType`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  1`(x86)/`  1`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
31    #[cfg_attr(feature = "serde", serde(rename = "type"))]
32    pub m_type: SubpartType,
33    /// # C++ Info
34    /// - name: `materialIndexStridingType`(ctype: `enum MaterialIndexStridingType`)
35    /// - offset: `  1`(x86)/`  1`(x86_64)
36    /// - type_size: `  1`(x86)/`  1`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndexStridingType"))]
38    #[cfg_attr(feature = "serde", serde(rename = "materialIndexStridingType"))]
39    pub m_materialIndexStridingType: MaterialIndexStridingType,
40    /// # C++ Info
41    /// - name: `materialStriding`(ctype: `hkInt16`)
42    /// - offset: `  2`(x86)/`  2`(x86_64)
43    /// - type_size: `  2`(x86)/`  2`(x86_64)
44    /// - flags: `SERIALIZE_IGNORED`
45    #[cfg_attr(feature = "json_schema", schemars(rename = "materialStriding"))]
46    #[cfg_attr(feature = "serde", serde(rename = "materialStriding"))]
47    pub m_materialStriding: i16,
48    /// # C++ Info
49    /// - name: `materialIndexBase`(ctype: `void*`)
50    /// - offset: `  4`(x86)/`  8`(x86_64)
51    /// - type_size: `  4`(x86)/`  8`(x86_64)
52    /// - flags: `SERIALIZE_IGNORED`
53    #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndexBase"))]
54    #[cfg_attr(feature = "serde", serde(rename = "materialIndexBase"))]
55    pub m_materialIndexBase: Pointer,
56    /// # C++ Info
57    /// - name: `materialIndexStriding`(ctype: `hkUint16`)
58    /// - offset: `  8`(x86)/` 16`(x86_64)
59    /// - type_size: `  2`(x86)/`  2`(x86_64)
60    #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndexStriding"))]
61    #[cfg_attr(feature = "serde", serde(rename = "materialIndexStriding"))]
62    pub m_materialIndexStriding: u16,
63    /// # C++ Info
64    /// - name: `numMaterials`(ctype: `hkUint16`)
65    /// - offset: ` 10`(x86)/` 18`(x86_64)
66    /// - type_size: `  2`(x86)/`  2`(x86_64)
67    #[cfg_attr(feature = "json_schema", schemars(rename = "numMaterials"))]
68    #[cfg_attr(feature = "serde", serde(rename = "numMaterials"))]
69    pub m_numMaterials: u16,
70    /// # C++ Info
71    /// - name: `materialBase`(ctype: `void*`)
72    /// - offset: ` 12`(x86)/` 24`(x86_64)
73    /// - type_size: `  4`(x86)/`  8`(x86_64)
74    /// - flags: `SERIALIZE_IGNORED`
75    #[cfg_attr(feature = "json_schema", schemars(rename = "materialBase"))]
76    #[cfg_attr(feature = "serde", serde(rename = "materialBase"))]
77    pub m_materialBase: Pointer,
78    /// # C++ Info
79    /// - name: `userData`(ctype: `hkUlong`)
80    /// - offset: ` 16`(x86)/` 32`(x86_64)
81    /// - type_size: `  4`(x86)/`  8`(x86_64)
82    #[cfg_attr(feature = "json_schema", schemars(rename = "userData"))]
83    #[cfg_attr(feature = "serde", serde(rename = "userData"))]
84    pub m_userData: Ulong,
85}
86const _: () = {
87    use havok_serde as _serde;
88    impl _serde::HavokClass for hkpExtendedMeshShapeSubpart {
89        #[inline]
90        fn name(&self) -> &'static str {
91            "hkpExtendedMeshShapeSubpart"
92        }
93        #[inline]
94        fn signature(&self) -> _serde::__private::Signature {
95            _serde::__private::Signature::new(0xf4608207)
96        }
97        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
98        fn deps_indexes(&self) -> Vec<usize> {
99            let mut v = Vec::new();
100            v.push(self.m_materialIndexBase.get());
101            v.push(self.m_materialBase.get());
102            v
103        }
104    }
105    impl _serde::Serialize for hkpExtendedMeshShapeSubpart {
106        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
107        where
108            S: _serde::ser::Serializer,
109        {
110            let class_meta = self
111                .__ptr
112                .map(|name| (name, _serde::__private::Signature::new(0xf4608207)));
113            let mut serializer = __serializer
114                .serialize_struct(
115                    "hkpExtendedMeshShapeSubpart",
116                    class_meta,
117                    (20u64, 40u64),
118                )?;
119            serializer.serialize_field("type", &self.m_type)?;
120            serializer
121                .serialize_field(
122                    "materialIndexStridingType",
123                    &self.m_materialIndexStridingType,
124                )?;
125            serializer.skip_field("materialStriding", &self.m_materialStriding)?;
126            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
127            serializer.skip_field("materialIndexBase", &self.m_materialIndexBase)?;
128            serializer
129                .serialize_field(
130                    "materialIndexStriding",
131                    &self.m_materialIndexStriding,
132                )?;
133            serializer.serialize_field("numMaterials", &self.m_numMaterials)?;
134            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
135            serializer.skip_field("materialBase", &self.m_materialBase)?;
136            serializer.serialize_field("userData", &self.m_userData)?;
137            serializer.end()
138        }
139    }
140};
141#[doc(hidden)]
142#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
143const _: () = {
144    use havok_serde as _serde;
145    #[automatically_derived]
146    impl<'de> _serde::Deserialize<'de> for hkpExtendedMeshShapeSubpart {
147        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
148        where
149            __D: _serde::Deserializer<'de>,
150        {
151            #[allow(non_camel_case_types)]
152            enum __Field {
153                m_type,
154                m_materialIndexStridingType,
155                m_materialIndexStriding,
156                m_numMaterials,
157                m_userData,
158                __ignore,
159            }
160            struct __FieldVisitor;
161            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
162                type Value = __Field;
163                fn expecting(
164                    &self,
165                    __formatter: &mut core::fmt::Formatter,
166                ) -> core::fmt::Result {
167                    core::fmt::Formatter::write_str(__formatter, "field identifier")
168                }
169                /// Intended for use in XML.
170                #[allow(clippy::match_single_binding)]
171                #[allow(clippy::reversed_empty_ranges)]
172                #[allow(clippy::single_match)]
173                fn visit_key<__E>(
174                    self,
175                    __value: &str,
176                ) -> core::result::Result<Self::Value, __E>
177                where
178                    __E: _serde::de::Error,
179                {
180                    match __value {
181                        "type" => Ok(__Field::m_type),
182                        "materialIndexStridingType" => {
183                            Ok(__Field::m_materialIndexStridingType)
184                        }
185                        "materialIndexStriding" => Ok(__Field::m_materialIndexStriding),
186                        "numMaterials" => Ok(__Field::m_numMaterials),
187                        "userData" => Ok(__Field::m_userData),
188                        _ => Ok(__Field::__ignore),
189                    }
190                }
191            }
192            impl<'de> _serde::Deserialize<'de> for __Field {
193                #[inline]
194                fn deserialize<__D>(
195                    __deserializer: __D,
196                ) -> core::result::Result<Self, __D::Error>
197                where
198                    __D: _serde::Deserializer<'de>,
199                {
200                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
201                }
202            }
203            struct __hkpExtendedMeshShapeSubpartVisitor<'de> {
204                marker: _serde::__private::PhantomData<hkpExtendedMeshShapeSubpart>,
205                lifetime: _serde::__private::PhantomData<&'de ()>,
206            }
207            #[allow(clippy::match_single_binding)]
208            #[allow(clippy::reversed_empty_ranges)]
209            #[allow(clippy::single_match)]
210            impl<'de> _serde::de::Visitor<'de>
211            for __hkpExtendedMeshShapeSubpartVisitor<'de> {
212                type Value = hkpExtendedMeshShapeSubpart;
213                fn expecting(
214                    &self,
215                    __formatter: &mut core::fmt::Formatter,
216                ) -> core::fmt::Result {
217                    core::fmt::Formatter::write_str(
218                        __formatter,
219                        "struct hkpExtendedMeshShapeSubpart",
220                    )
221                }
222                fn visit_struct_for_bytes<__A>(
223                    self,
224                    mut __map: __A,
225                ) -> _serde::__private::Result<Self::Value, __A::Error>
226                where
227                    __A: _serde::de::MapAccess<'de>,
228                {
229                    let __ptr = __A::class_ptr(&mut __map);
230                    let mut m_type: _serde::__private::Option<SubpartType> = _serde::__private::None;
231                    let mut m_materialIndexStridingType: _serde::__private::Option<
232                        MaterialIndexStridingType,
233                    > = _serde::__private::None;
234                    let mut m_materialStriding: _serde::__private::Option<i16> = _serde::__private::None;
235                    let mut m_materialIndexBase: _serde::__private::Option<Pointer> = _serde::__private::None;
236                    let mut m_materialIndexStriding: _serde::__private::Option<u16> = _serde::__private::None;
237                    let mut m_numMaterials: _serde::__private::Option<u16> = _serde::__private::None;
238                    let mut m_materialBase: _serde::__private::Option<Pointer> = _serde::__private::None;
239                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
240                    for i in 0..8usize {
241                        match i {
242                            0usize => {
243                                if _serde::__private::Option::is_some(&m_type) {
244                                    return _serde::__private::Err(
245                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
246                                    );
247                                }
248                                m_type = _serde::__private::Some(
249                                    match __A::next_value::<SubpartType>(&mut __map) {
250                                        _serde::__private::Ok(__val) => __val,
251                                        _serde::__private::Err(__err) => {
252                                            return _serde::__private::Err(__err);
253                                        }
254                                    },
255                                );
256                            }
257                            1usize => {
258                                if _serde::__private::Option::is_some(
259                                    &m_materialIndexStridingType,
260                                ) {
261                                    return _serde::__private::Err(
262                                        <__A::Error as _serde::de::Error>::duplicate_field(
263                                            "materialIndexStridingType",
264                                        ),
265                                    );
266                                }
267                                m_materialIndexStridingType = _serde::__private::Some(
268                                    match __A::next_value::<
269                                        MaterialIndexStridingType,
270                                    >(&mut __map) {
271                                        _serde::__private::Ok(__val) => __val,
272                                        _serde::__private::Err(__err) => {
273                                            return _serde::__private::Err(__err);
274                                        }
275                                    },
276                                );
277                            }
278                            2usize => {
279                                if _serde::__private::Option::is_some(&m_materialStriding) {
280                                    return _serde::__private::Err(
281                                        <__A::Error as _serde::de::Error>::duplicate_field(
282                                            "materialStriding",
283                                        ),
284                                    );
285                                }
286                                m_materialStriding = _serde::__private::Some(
287                                    match __A::next_value::<i16>(&mut __map) {
288                                        _serde::__private::Ok(__val) => __val,
289                                        _serde::__private::Err(__err) => {
290                                            return _serde::__private::Err(__err);
291                                        }
292                                    },
293                                );
294                            }
295                            3usize => {
296                                if _serde::__private::Option::is_some(
297                                    &m_materialIndexBase,
298                                ) {
299                                    return _serde::__private::Err(
300                                        <__A::Error as _serde::de::Error>::duplicate_field(
301                                            "materialIndexBase",
302                                        ),
303                                    );
304                                }
305                                __A::pad(&mut __map, 0usize, 4usize)?;
306                                m_materialIndexBase = _serde::__private::Some(
307                                    match __A::next_value::<Pointer>(&mut __map) {
308                                        _serde::__private::Ok(__val) => __val,
309                                        _serde::__private::Err(__err) => {
310                                            return _serde::__private::Err(__err);
311                                        }
312                                    },
313                                );
314                            }
315                            4usize => {
316                                if _serde::__private::Option::is_some(
317                                    &m_materialIndexStriding,
318                                ) {
319                                    return _serde::__private::Err(
320                                        <__A::Error as _serde::de::Error>::duplicate_field(
321                                            "materialIndexStriding",
322                                        ),
323                                    );
324                                }
325                                m_materialIndexStriding = _serde::__private::Some(
326                                    match __A::next_value::<u16>(&mut __map) {
327                                        _serde::__private::Ok(__val) => __val,
328                                        _serde::__private::Err(__err) => {
329                                            return _serde::__private::Err(__err);
330                                        }
331                                    },
332                                );
333                            }
334                            5usize => {
335                                if _serde::__private::Option::is_some(&m_numMaterials) {
336                                    return _serde::__private::Err(
337                                        <__A::Error as _serde::de::Error>::duplicate_field(
338                                            "numMaterials",
339                                        ),
340                                    );
341                                }
342                                m_numMaterials = _serde::__private::Some(
343                                    match __A::next_value::<u16>(&mut __map) {
344                                        _serde::__private::Ok(__val) => __val,
345                                        _serde::__private::Err(__err) => {
346                                            return _serde::__private::Err(__err);
347                                        }
348                                    },
349                                );
350                            }
351                            6usize => {
352                                if _serde::__private::Option::is_some(&m_materialBase) {
353                                    return _serde::__private::Err(
354                                        <__A::Error as _serde::de::Error>::duplicate_field(
355                                            "materialBase",
356                                        ),
357                                    );
358                                }
359                                __A::pad(&mut __map, 0usize, 4usize)?;
360                                m_materialBase = _serde::__private::Some(
361                                    match __A::next_value::<Pointer>(&mut __map) {
362                                        _serde::__private::Ok(__val) => __val,
363                                        _serde::__private::Err(__err) => {
364                                            return _serde::__private::Err(__err);
365                                        }
366                                    },
367                                );
368                            }
369                            7usize => {
370                                if _serde::__private::Option::is_some(&m_userData) {
371                                    return _serde::__private::Err(
372                                        <__A::Error as _serde::de::Error>::duplicate_field(
373                                            "userData",
374                                        ),
375                                    );
376                                }
377                                m_userData = _serde::__private::Some(
378                                    match __A::next_value::<Ulong>(&mut __map) {
379                                        _serde::__private::Ok(__val) => __val,
380                                        _serde::__private::Err(__err) => {
381                                            return _serde::__private::Err(__err);
382                                        }
383                                    },
384                                );
385                            }
386                            _ => {}
387                        }
388                    }
389                    let m_type = match m_type {
390                        _serde::__private::Some(__field) => __field,
391                        _serde::__private::None => {
392                            return _serde::__private::Err(
393                                <__A::Error as _serde::de::Error>::missing_field("type"),
394                            );
395                        }
396                    };
397                    let m_materialIndexStridingType = match m_materialIndexStridingType {
398                        _serde::__private::Some(__field) => __field,
399                        _serde::__private::None => {
400                            return _serde::__private::Err(
401                                <__A::Error as _serde::de::Error>::missing_field(
402                                    "materialIndexStridingType",
403                                ),
404                            );
405                        }
406                    };
407                    let m_materialStriding = match m_materialStriding {
408                        _serde::__private::Some(__field) => __field,
409                        _serde::__private::None => {
410                            return _serde::__private::Err(
411                                <__A::Error as _serde::de::Error>::missing_field(
412                                    "materialStriding",
413                                ),
414                            );
415                        }
416                    };
417                    let m_materialIndexBase = match m_materialIndexBase {
418                        _serde::__private::Some(__field) => __field,
419                        _serde::__private::None => {
420                            return _serde::__private::Err(
421                                <__A::Error as _serde::de::Error>::missing_field(
422                                    "materialIndexBase",
423                                ),
424                            );
425                        }
426                    };
427                    let m_materialIndexStriding = match m_materialIndexStriding {
428                        _serde::__private::Some(__field) => __field,
429                        _serde::__private::None => {
430                            return _serde::__private::Err(
431                                <__A::Error as _serde::de::Error>::missing_field(
432                                    "materialIndexStriding",
433                                ),
434                            );
435                        }
436                    };
437                    let m_numMaterials = match m_numMaterials {
438                        _serde::__private::Some(__field) => __field,
439                        _serde::__private::None => {
440                            return _serde::__private::Err(
441                                <__A::Error as _serde::de::Error>::missing_field(
442                                    "numMaterials",
443                                ),
444                            );
445                        }
446                    };
447                    let m_materialBase = match m_materialBase {
448                        _serde::__private::Some(__field) => __field,
449                        _serde::__private::None => {
450                            return _serde::__private::Err(
451                                <__A::Error as _serde::de::Error>::missing_field(
452                                    "materialBase",
453                                ),
454                            );
455                        }
456                    };
457                    let m_userData = match m_userData {
458                        _serde::__private::Some(__field) => __field,
459                        _serde::__private::None => {
460                            return _serde::__private::Err(
461                                <__A::Error as _serde::de::Error>::missing_field("userData"),
462                            );
463                        }
464                    };
465                    _serde::__private::Ok(hkpExtendedMeshShapeSubpart {
466                        __ptr,
467                        m_type,
468                        m_materialIndexStridingType,
469                        m_materialStriding,
470                        m_materialIndexBase,
471                        m_materialIndexStriding,
472                        m_numMaterials,
473                        m_materialBase,
474                        m_userData,
475                    })
476                }
477                #[allow(clippy::manual_unwrap_or_default)]
478                fn visit_struct<__A>(
479                    self,
480                    mut __map: __A,
481                ) -> _serde::__private::Result<Self::Value, __A::Error>
482                where
483                    __A: _serde::de::MapAccess<'de>,
484                {
485                    let mut m_type: _serde::__private::Option<SubpartType> = _serde::__private::None;
486                    let mut m_materialIndexStridingType: _serde::__private::Option<
487                        MaterialIndexStridingType,
488                    > = _serde::__private::None;
489                    let mut m_materialIndexStriding: _serde::__private::Option<u16> = _serde::__private::None;
490                    let mut m_numMaterials: _serde::__private::Option<u16> = _serde::__private::None;
491                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
492                    while let _serde::__private::Some(__key) = {
493                        __A::next_key::<__Field>(&mut __map)?
494                    } {
495                        match __key {
496                            __Field::m_type => {
497                                #[cfg(
498                                    any(feature = "strict", feature = "ignore_duplicates")
499                                )]
500                                if _serde::__private::Option::is_some(&m_type) {
501                                    #[cfg(feature = "ignore_duplicates")]
502                                    {
503                                        __A::skip_value(&mut __map)?;
504                                        continue;
505                                    }
506                                    #[cfg(feature = "strict")]
507                                    return _serde::__private::Err(
508                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
509                                    );
510                                }
511                                m_type = _serde::__private::Some(
512                                    match __A::next_value::<SubpartType>(&mut __map) {
513                                        _serde::__private::Ok(__val) => __val,
514                                        _serde::__private::Err(__err) => {
515                                            return _serde::__private::Err(__err);
516                                        }
517                                    },
518                                );
519                            }
520                            __Field::m_materialIndexStridingType => {
521                                #[cfg(
522                                    any(feature = "strict", feature = "ignore_duplicates")
523                                )]
524                                if _serde::__private::Option::is_some(
525                                    &m_materialIndexStridingType,
526                                ) {
527                                    #[cfg(feature = "ignore_duplicates")]
528                                    {
529                                        __A::skip_value(&mut __map)?;
530                                        continue;
531                                    }
532                                    #[cfg(feature = "strict")]
533                                    return _serde::__private::Err(
534                                        <__A::Error as _serde::de::Error>::duplicate_field(
535                                            "materialIndexStridingType",
536                                        ),
537                                    );
538                                }
539                                m_materialIndexStridingType = _serde::__private::Some(
540                                    match __A::next_value::<
541                                        MaterialIndexStridingType,
542                                    >(&mut __map) {
543                                        _serde::__private::Ok(__val) => __val,
544                                        _serde::__private::Err(__err) => {
545                                            return _serde::__private::Err(__err);
546                                        }
547                                    },
548                                );
549                            }
550                            __Field::m_materialIndexStriding => {
551                                #[cfg(
552                                    any(feature = "strict", feature = "ignore_duplicates")
553                                )]
554                                if _serde::__private::Option::is_some(
555                                    &m_materialIndexStriding,
556                                ) {
557                                    #[cfg(feature = "ignore_duplicates")]
558                                    {
559                                        __A::skip_value(&mut __map)?;
560                                        continue;
561                                    }
562                                    #[cfg(feature = "strict")]
563                                    return _serde::__private::Err(
564                                        <__A::Error as _serde::de::Error>::duplicate_field(
565                                            "materialIndexStriding",
566                                        ),
567                                    );
568                                }
569                                m_materialIndexStriding = _serde::__private::Some(
570                                    match __A::next_value::<u16>(&mut __map) {
571                                        _serde::__private::Ok(__val) => __val,
572                                        _serde::__private::Err(__err) => {
573                                            return _serde::__private::Err(__err);
574                                        }
575                                    },
576                                );
577                            }
578                            __Field::m_numMaterials => {
579                                #[cfg(
580                                    any(feature = "strict", feature = "ignore_duplicates")
581                                )]
582                                if _serde::__private::Option::is_some(&m_numMaterials) {
583                                    #[cfg(feature = "ignore_duplicates")]
584                                    {
585                                        __A::skip_value(&mut __map)?;
586                                        continue;
587                                    }
588                                    #[cfg(feature = "strict")]
589                                    return _serde::__private::Err(
590                                        <__A::Error as _serde::de::Error>::duplicate_field(
591                                            "numMaterials",
592                                        ),
593                                    );
594                                }
595                                m_numMaterials = _serde::__private::Some(
596                                    match __A::next_value::<u16>(&mut __map) {
597                                        _serde::__private::Ok(__val) => __val,
598                                        _serde::__private::Err(__err) => {
599                                            return _serde::__private::Err(__err);
600                                        }
601                                    },
602                                );
603                            }
604                            __Field::m_userData => {
605                                #[cfg(
606                                    any(feature = "strict", feature = "ignore_duplicates")
607                                )]
608                                if _serde::__private::Option::is_some(&m_userData) {
609                                    #[cfg(feature = "ignore_duplicates")]
610                                    {
611                                        __A::skip_value(&mut __map)?;
612                                        continue;
613                                    }
614                                    #[cfg(feature = "strict")]
615                                    return _serde::__private::Err(
616                                        <__A::Error as _serde::de::Error>::duplicate_field(
617                                            "userData",
618                                        ),
619                                    );
620                                }
621                                m_userData = _serde::__private::Some(
622                                    match __A::next_value::<Ulong>(&mut __map) {
623                                        _serde::__private::Ok(__val) => __val,
624                                        _serde::__private::Err(__err) => {
625                                            return _serde::__private::Err(__err);
626                                        }
627                                    },
628                                );
629                            }
630                            _ => __A::skip_value(&mut __map)?,
631                        }
632                    }
633                    let m_type = match m_type {
634                        _serde::__private::Some(__field) => __field,
635                        _serde::__private::None => {
636                            #[cfg(feature = "strict")]
637                            return _serde::__private::Err(
638                                <__A::Error as _serde::de::Error>::missing_field("type"),
639                            );
640                            #[cfg(not(feature = "strict"))] Default::default()
641                        }
642                    };
643                    let m_materialIndexStridingType = match m_materialIndexStridingType {
644                        _serde::__private::Some(__field) => __field,
645                        _serde::__private::None => {
646                            #[cfg(feature = "strict")]
647                            return _serde::__private::Err(
648                                <__A::Error as _serde::de::Error>::missing_field(
649                                    "materialIndexStridingType",
650                                ),
651                            );
652                            #[cfg(not(feature = "strict"))] Default::default()
653                        }
654                    };
655                    let m_materialIndexStriding = match m_materialIndexStriding {
656                        _serde::__private::Some(__field) => __field,
657                        _serde::__private::None => {
658                            #[cfg(feature = "strict")]
659                            return _serde::__private::Err(
660                                <__A::Error as _serde::de::Error>::missing_field(
661                                    "materialIndexStriding",
662                                ),
663                            );
664                            #[cfg(not(feature = "strict"))] Default::default()
665                        }
666                    };
667                    let m_numMaterials = match m_numMaterials {
668                        _serde::__private::Some(__field) => __field,
669                        _serde::__private::None => {
670                            #[cfg(feature = "strict")]
671                            return _serde::__private::Err(
672                                <__A::Error as _serde::de::Error>::missing_field(
673                                    "numMaterials",
674                                ),
675                            );
676                            #[cfg(not(feature = "strict"))] Default::default()
677                        }
678                    };
679                    let m_userData = match m_userData {
680                        _serde::__private::Some(__field) => __field,
681                        _serde::__private::None => {
682                            #[cfg(feature = "strict")]
683                            return _serde::__private::Err(
684                                <__A::Error as _serde::de::Error>::missing_field("userData"),
685                            );
686                            #[cfg(not(feature = "strict"))] Default::default()
687                        }
688                    };
689                    let __ptr = __A::class_ptr(&mut __map);
690                    _serde::__private::Ok(hkpExtendedMeshShapeSubpart {
691                        __ptr,
692                        m_type,
693                        m_materialIndexStridingType,
694                        m_materialIndexStriding,
695                        m_numMaterials,
696                        m_userData,
697                        ..Default::default()
698                    })
699                }
700            }
701            const FIELDS: &[&str] = &[
702                "type",
703                "materialIndexStridingType",
704                "materialStriding",
705                "materialIndexBase",
706                "materialIndexStriding",
707                "numMaterials",
708                "materialBase",
709                "userData",
710            ];
711            _serde::Deserializer::deserialize_struct(
712                deserializer,
713                "hkpExtendedMeshShapeSubpart",
714                FIELDS,
715                __hkpExtendedMeshShapeSubpartVisitor {
716                    marker: _serde::__private::PhantomData::<
717                        hkpExtendedMeshShapeSubpart,
718                    >,
719                    lifetime: _serde::__private::PhantomData,
720                },
721            )
722        }
723    }
724};