havok_classes/generated/
hkpConvexVerticesShape_.rs

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