havok_classes/generated/
hkpCompressedMeshShapeConvexPiece_.rs

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

havok_classes/generated/
hkpCompressedMeshShapeConvexPiece_.rs
