havok_classes/generated/
hkMoppBvTreeShapeBase_.rs

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

havok_classes/generated/
hkMoppBvTreeShapeBase_.rs
