havok_classes/generated/
hkpCollidableBoundingVolumeData_.rs

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