havok_classes/generated/
hkpShapePhantom_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpShapePhantom`
5/// - version: `0`
6/// - signature: `0xcb22fbcd`
7/// - size: `352`(x86)/`416`(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 hkpShapePhantom<'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    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkpPhantom<'a>,
31    /// # C++ Info
32    /// - name: `motionState`(ctype: `struct hkMotionState`)
33    /// - offset: `176`(x86)/`240`(x86_64)
34    /// - type_size: `176`(x86)/`176`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "motionState"))]
36    #[cfg_attr(feature = "serde", serde(rename = "motionState"))]
37    pub m_motionState: hkMotionState,
38}
39const _: () = {
40    use havok_serde as _serde;
41    impl<'a> _serde::HavokClass for hkpShapePhantom<'a> {
42        #[inline]
43        fn name(&self) -> &'static str {
44            "hkpShapePhantom"
45        }
46        #[inline]
47        fn signature(&self) -> _serde::__private::Signature {
48            _serde::__private::Signature::new(0xcb22fbcd)
49        }
50        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
51        fn deps_indexes(&self) -> Vec<usize> {
52            let mut v = Vec::new();
53            v.push(self.parent.parent.m_world.get());
54            v.extend(self.parent.parent.m_collidable.deps_indexes());
55            v.extend(self.parent.parent.m_multiThreadCheck.deps_indexes());
56            v.extend(
57                self
58                    .parent
59                    .parent
60                    .m_properties
61                    .iter()
62                    .flat_map(|class| class.deps_indexes())
63                    .collect::<Vec<usize>>(),
64            );
65            v.push(self.parent.parent.m_treeData.get());
66            v.extend(self.parent.m_overlapListeners.iter().map(|ptr| ptr.get()));
67            v.extend(self.parent.m_phantomListeners.iter().map(|ptr| ptr.get()));
68            v.extend(self.m_motionState.deps_indexes());
69            v
70        }
71    }
72    impl<'a> _serde::Serialize for hkpShapePhantom<'a> {
73        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
74        where
75            S: _serde::ser::Serializer,
76        {
77            let class_meta = self
78                .__ptr
79                .map(|name| (name, _serde::__private::Signature::new(0xcb22fbcd)));
80            let mut serializer = __serializer
81                .serialize_struct("hkpShapePhantom", class_meta, (352u64, 416u64))?;
82            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
83            serializer
84                .skip_field(
85                    "memSizeAndFlags",
86                    &self.parent.parent.parent.m_memSizeAndFlags,
87                )?;
88            serializer
89                .skip_field(
90                    "referenceCount",
91                    &self.parent.parent.parent.m_referenceCount,
92                )?;
93            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
94            serializer.skip_field("world", &self.parent.parent.m_world)?;
95            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
96            serializer.serialize_field("collidable", &self.parent.parent.m_collidable)?;
97            serializer
98                .serialize_field(
99                    "multiThreadCheck",
100                    &self.parent.parent.m_multiThreadCheck,
101                )?;
102            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
103            serializer.serialize_field("name", &self.parent.parent.m_name)?;
104            serializer
105                .serialize_array_field(
106                    "properties",
107                    &self.parent.parent.m_properties,
108                    TypeSize::Struct {
109                        size_x86: 16u64,
110                        size_x86_64: 16u64,
111                    },
112                )?;
113            serializer.skip_field("treeData", &self.parent.parent.m_treeData)?;
114            serializer
115                .skip_array_field(
116                    "overlapListeners",
117                    &self.parent.m_overlapListeners,
118                    TypeSize::NonPtr,
119                )?;
120            serializer
121                .skip_array_field(
122                    "phantomListeners",
123                    &self.parent.m_phantomListeners,
124                    TypeSize::NonPtr,
125                )?;
126            serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 0usize].as_slice())?;
127            serializer.serialize_field("motionState", &self.m_motionState)?;
128            serializer.end()
129        }
130    }
131};
132#[doc(hidden)]
133#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
134const _: () = {
135    use havok_serde as _serde;
136    #[automatically_derived]
137    impl<'de> _serde::Deserialize<'de> for hkpShapePhantom<'de> {
138        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
139        where
140            __D: _serde::Deserializer<'de>,
141        {
142            #[allow(non_camel_case_types)]
143            enum __Field {
144                m_userData,
145                m_collidable,
146                m_multiThreadCheck,
147                m_name,
148                m_properties,
149                m_motionState,
150                __ignore,
151            }
152            struct __FieldVisitor;
153            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
154                type Value = __Field;
155                fn expecting(
156                    &self,
157                    __formatter: &mut core::fmt::Formatter,
158                ) -> core::fmt::Result {
159                    core::fmt::Formatter::write_str(__formatter, "field identifier")
160                }
161                /// Intended for use in XML.
162                #[allow(clippy::match_single_binding)]
163                #[allow(clippy::reversed_empty_ranges)]
164                #[allow(clippy::single_match)]
165                fn visit_key<__E>(
166                    self,
167                    __value: &str,
168                ) -> core::result::Result<Self::Value, __E>
169                where
170                    __E: _serde::de::Error,
171                {
172                    match __value {
173                        "userData" => Ok(__Field::m_userData),
174                        "collidable" => Ok(__Field::m_collidable),
175                        "multiThreadCheck" => Ok(__Field::m_multiThreadCheck),
176                        "name" => Ok(__Field::m_name),
177                        "properties" => Ok(__Field::m_properties),
178                        "motionState" => Ok(__Field::m_motionState),
179                        _ => Ok(__Field::__ignore),
180                    }
181                }
182            }
183            impl<'de> _serde::Deserialize<'de> for __Field {
184                #[inline]
185                fn deserialize<__D>(
186                    __deserializer: __D,
187                ) -> core::result::Result<Self, __D::Error>
188                where
189                    __D: _serde::Deserializer<'de>,
190                {
191                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
192                }
193            }
194            struct __hkpShapePhantomVisitor<'de> {
195                marker: _serde::__private::PhantomData<hkpShapePhantom<'de>>,
196                lifetime: _serde::__private::PhantomData<&'de ()>,
197            }
198            #[allow(clippy::match_single_binding)]
199            #[allow(clippy::reversed_empty_ranges)]
200            #[allow(clippy::single_match)]
201            impl<'de> _serde::de::Visitor<'de> for __hkpShapePhantomVisitor<'de> {
202                type Value = hkpShapePhantom<'de>;
203                fn expecting(
204                    &self,
205                    __formatter: &mut core::fmt::Formatter,
206                ) -> core::fmt::Result {
207                    core::fmt::Formatter::write_str(
208                        __formatter,
209                        "struct hkpShapePhantom",
210                    )
211                }
212                fn visit_struct_for_bytes<__A>(
213                    self,
214                    mut __map: __A,
215                ) -> _serde::__private::Result<Self::Value, __A::Error>
216                where
217                    __A: _serde::de::MapAccess<'de>,
218                {
219                    let __ptr = __A::class_ptr(&mut __map);
220                    let parent = __A::parent_value(&mut __map)?;
221                    let mut m_motionState: _serde::__private::Option<hkMotionState> = _serde::__private::None;
222                    for i in 0..1usize {
223                        match i {
224                            0usize => {
225                                if _serde::__private::Option::is_some(&m_motionState) {
226                                    return _serde::__private::Err(
227                                        <__A::Error as _serde::de::Error>::duplicate_field(
228                                            "motionState",
229                                        ),
230                                    );
231                                }
232                                __A::pad(&mut __map, 12usize, 0usize)?;
233                                m_motionState = _serde::__private::Some(
234                                    match __A::next_value::<hkMotionState>(&mut __map) {
235                                        _serde::__private::Ok(__val) => __val,
236                                        _serde::__private::Err(__err) => {
237                                            return _serde::__private::Err(__err);
238                                        }
239                                    },
240                                );
241                            }
242                            _ => {}
243                        }
244                    }
245                    let m_motionState = match m_motionState {
246                        _serde::__private::Some(__field) => __field,
247                        _serde::__private::None => {
248                            return _serde::__private::Err(
249                                <__A::Error as _serde::de::Error>::missing_field(
250                                    "motionState",
251                                ),
252                            );
253                        }
254                    };
255                    _serde::__private::Ok(hkpShapePhantom {
256                        __ptr,
257                        parent,
258                        m_motionState,
259                    })
260                }
261                #[allow(clippy::manual_unwrap_or_default)]
262                fn visit_struct<__A>(
263                    self,
264                    mut __map: __A,
265                ) -> _serde::__private::Result<Self::Value, __A::Error>
266                where
267                    __A: _serde::de::MapAccess<'de>,
268                {
269                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
270                    let mut m_collidable: _serde::__private::Option<
271                        hkpLinkedCollidable,
272                    > = _serde::__private::None;
273                    let mut m_multiThreadCheck: _serde::__private::Option<
274                        hkMultiThreadCheck,
275                    > = _serde::__private::None;
276                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
277                    let mut m_properties: _serde::__private::Option<Vec<hkpProperty>> = _serde::__private::None;
278                    let mut m_motionState: _serde::__private::Option<hkMotionState> = _serde::__private::None;
279                    while let _serde::__private::Some(__key) = {
280                        __A::next_key::<__Field>(&mut __map)?
281                    } {
282                        match __key {
283                            __Field::m_userData => {
284                                #[cfg(
285                                    any(feature = "strict", feature = "ignore_duplicates")
286                                )]
287                                if _serde::__private::Option::is_some(&m_userData) {
288                                    #[cfg(feature = "ignore_duplicates")]
289                                    {
290                                        __A::skip_value(&mut __map)?;
291                                        continue;
292                                    }
293                                    #[cfg(feature = "strict")]
294                                    return _serde::__private::Err(
295                                        <__A::Error as _serde::de::Error>::duplicate_field(
296                                            "userData",
297                                        ),
298                                    );
299                                }
300                                m_userData = _serde::__private::Some(
301                                    match __A::next_value::<Ulong>(&mut __map) {
302                                        _serde::__private::Ok(__val) => __val,
303                                        _serde::__private::Err(__err) => {
304                                            return _serde::__private::Err(__err);
305                                        }
306                                    },
307                                );
308                            }
309                            __Field::m_collidable => {
310                                #[cfg(
311                                    any(feature = "strict", feature = "ignore_duplicates")
312                                )]
313                                if _serde::__private::Option::is_some(&m_collidable) {
314                                    #[cfg(feature = "ignore_duplicates")]
315                                    {
316                                        __A::skip_value(&mut __map)?;
317                                        continue;
318                                    }
319                                    #[cfg(feature = "strict")]
320                                    return _serde::__private::Err(
321                                        <__A::Error as _serde::de::Error>::duplicate_field(
322                                            "collidable",
323                                        ),
324                                    );
325                                }
326                                m_collidable = _serde::__private::Some(
327                                    match __A::next_value::<hkpLinkedCollidable>(&mut __map) {
328                                        _serde::__private::Ok(__val) => __val,
329                                        _serde::__private::Err(__err) => {
330                                            return _serde::__private::Err(__err);
331                                        }
332                                    },
333                                );
334                            }
335                            __Field::m_multiThreadCheck => {
336                                #[cfg(
337                                    any(feature = "strict", feature = "ignore_duplicates")
338                                )]
339                                if _serde::__private::Option::is_some(&m_multiThreadCheck) {
340                                    #[cfg(feature = "ignore_duplicates")]
341                                    {
342                                        __A::skip_value(&mut __map)?;
343                                        continue;
344                                    }
345                                    #[cfg(feature = "strict")]
346                                    return _serde::__private::Err(
347                                        <__A::Error as _serde::de::Error>::duplicate_field(
348                                            "multiThreadCheck",
349                                        ),
350                                    );
351                                }
352                                m_multiThreadCheck = _serde::__private::Some(
353                                    match __A::next_value::<hkMultiThreadCheck>(&mut __map) {
354                                        _serde::__private::Ok(__val) => __val,
355                                        _serde::__private::Err(__err) => {
356                                            return _serde::__private::Err(__err);
357                                        }
358                                    },
359                                );
360                            }
361                            __Field::m_name => {
362                                #[cfg(
363                                    any(feature = "strict", feature = "ignore_duplicates")
364                                )]
365                                if _serde::__private::Option::is_some(&m_name) {
366                                    #[cfg(feature = "ignore_duplicates")]
367                                    {
368                                        __A::skip_value(&mut __map)?;
369                                        continue;
370                                    }
371                                    #[cfg(feature = "strict")]
372                                    return _serde::__private::Err(
373                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
374                                    );
375                                }
376                                m_name = _serde::__private::Some(
377                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
378                                        _serde::__private::Ok(__val) => __val,
379                                        _serde::__private::Err(__err) => {
380                                            return _serde::__private::Err(__err);
381                                        }
382                                    },
383                                );
384                            }
385                            __Field::m_properties => {
386                                #[cfg(
387                                    any(feature = "strict", feature = "ignore_duplicates")
388                                )]
389                                if _serde::__private::Option::is_some(&m_properties) {
390                                    #[cfg(feature = "ignore_duplicates")]
391                                    {
392                                        __A::skip_value(&mut __map)?;
393                                        continue;
394                                    }
395                                    #[cfg(feature = "strict")]
396                                    return _serde::__private::Err(
397                                        <__A::Error as _serde::de::Error>::duplicate_field(
398                                            "properties",
399                                        ),
400                                    );
401                                }
402                                m_properties = _serde::__private::Some(
403                                    match __A::next_value::<Vec<hkpProperty>>(&mut __map) {
404                                        _serde::__private::Ok(__val) => __val,
405                                        _serde::__private::Err(__err) => {
406                                            return _serde::__private::Err(__err);
407                                        }
408                                    },
409                                );
410                            }
411                            __Field::m_motionState => {
412                                #[cfg(
413                                    any(feature = "strict", feature = "ignore_duplicates")
414                                )]
415                                if _serde::__private::Option::is_some(&m_motionState) {
416                                    #[cfg(feature = "ignore_duplicates")]
417                                    {
418                                        __A::skip_value(&mut __map)?;
419                                        continue;
420                                    }
421                                    #[cfg(feature = "strict")]
422                                    return _serde::__private::Err(
423                                        <__A::Error as _serde::de::Error>::duplicate_field(
424                                            "motionState",
425                                        ),
426                                    );
427                                }
428                                m_motionState = _serde::__private::Some(
429                                    match __A::next_value::<hkMotionState>(&mut __map) {
430                                        _serde::__private::Ok(__val) => __val,
431                                        _serde::__private::Err(__err) => {
432                                            return _serde::__private::Err(__err);
433                                        }
434                                    },
435                                );
436                            }
437                            _ => __A::skip_value(&mut __map)?,
438                        }
439                    }
440                    let m_userData = match m_userData {
441                        _serde::__private::Some(__field) => __field,
442                        _serde::__private::None => {
443                            #[cfg(feature = "strict")]
444                            return _serde::__private::Err(
445                                <__A::Error as _serde::de::Error>::missing_field("userData"),
446                            );
447                            #[cfg(not(feature = "strict"))] Default::default()
448                        }
449                    };
450                    let m_collidable = match m_collidable {
451                        _serde::__private::Some(__field) => __field,
452                        _serde::__private::None => {
453                            #[cfg(feature = "strict")]
454                            return _serde::__private::Err(
455                                <__A::Error as _serde::de::Error>::missing_field(
456                                    "collidable",
457                                ),
458                            );
459                            #[cfg(not(feature = "strict"))] Default::default()
460                        }
461                    };
462                    let m_multiThreadCheck = match m_multiThreadCheck {
463                        _serde::__private::Some(__field) => __field,
464                        _serde::__private::None => {
465                            #[cfg(feature = "strict")]
466                            return _serde::__private::Err(
467                                <__A::Error as _serde::de::Error>::missing_field(
468                                    "multiThreadCheck",
469                                ),
470                            );
471                            #[cfg(not(feature = "strict"))] Default::default()
472                        }
473                    };
474                    let m_name = match m_name {
475                        _serde::__private::Some(__field) => __field,
476                        _serde::__private::None => {
477                            #[cfg(feature = "strict")]
478                            return _serde::__private::Err(
479                                <__A::Error as _serde::de::Error>::missing_field("name"),
480                            );
481                            #[cfg(not(feature = "strict"))] Default::default()
482                        }
483                    };
484                    let m_properties = match m_properties {
485                        _serde::__private::Some(__field) => __field,
486                        _serde::__private::None => {
487                            #[cfg(feature = "strict")]
488                            return _serde::__private::Err(
489                                <__A::Error as _serde::de::Error>::missing_field(
490                                    "properties",
491                                ),
492                            );
493                            #[cfg(not(feature = "strict"))] Default::default()
494                        }
495                    };
496                    let m_motionState = match m_motionState {
497                        _serde::__private::Some(__field) => __field,
498                        _serde::__private::None => {
499                            #[cfg(feature = "strict")]
500                            return _serde::__private::Err(
501                                <__A::Error as _serde::de::Error>::missing_field(
502                                    "motionState",
503                                ),
504                            );
505                            #[cfg(not(feature = "strict"))] Default::default()
506                        }
507                    };
508                    let __ptr = None;
509                    let parent = hkBaseObject { __ptr };
510                    let parent = hkReferencedObject {
511                        __ptr,
512                        parent,
513                        ..Default::default()
514                    };
515                    let parent = hkpWorldObject {
516                        __ptr,
517                        parent,
518                        m_userData,
519                        m_collidable,
520                        m_multiThreadCheck,
521                        m_name,
522                        m_properties,
523                        ..Default::default()
524                    };
525                    let parent = hkpPhantom {
526                        __ptr,
527                        parent,
528                        ..Default::default()
529                    };
530                    let __ptr = __A::class_ptr(&mut __map);
531                    _serde::__private::Ok(hkpShapePhantom {
532                        __ptr,
533                        parent,
534                        m_motionState,
535                    })
536                }
537            }
538            const FIELDS: &[&str] = &["motionState"];
539            _serde::Deserializer::deserialize_struct(
540                deserializer,
541                "hkpShapePhantom",
542                FIELDS,
543                __hkpShapePhantomVisitor {
544                    marker: _serde::__private::PhantomData::<hkpShapePhantom>,
545                    lifetime: _serde::__private::PhantomData,
546                },
547            )
548        }
549    }
550};