havok_classes/generated/
hkpCollidable_.rs

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

havok_classes/generated/
hkpCollidable_.rs
