havok_classes/generated/
hkpSimpleMeshShape_.rs

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

havok_classes/generated/
hkpSimpleMeshShape_.rs
