havok_classes/generated/
hkpPhantom_.rs

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

havok_classes/generated/
hkpPhantom_.rs
