havok_classes/generated/
hkpExtendedMeshShapeShapesSubpart_.rs

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