havok_classes/generated/
hkpStorageMeshShapeSubpartStorage_.rs

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

havok_classes/generated/
hkpStorageMeshShapeSubpartStorage_.rs
