havok_classes/generated/
hkpStorageMeshShape_.rs

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