havok_classes/generated/
hkpFastMeshShape_.rs

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