havok_classes/generated/
hkpCompressedMeshShapeChunk_.rs

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