havok_classes/generated/
hkpBvTreeShape_.rs

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