havok_classes/generated/
hkpShapeInfo_.rs

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

havok_classes/generated/
hkpShapeInfo_.rs
