havok_classes/generated/
hkpMoppCode_.rs

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