havok_classes/generated/
hkbProjectData_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbProjectData`
5/// - version: `2`
6/// - signature: `0x13a39ba7`
7/// - size: ` 48`(x86)/` 48`(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 hkbProjectData {
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: `worldUpWS`(ctype: `hkVector4`)
32    /// - offset: ` 16`(x86)/` 16`(x86_64)
33    /// - type_size: ` 16`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "worldUpWS"))]
35    #[cfg_attr(feature = "serde", serde(rename = "worldUpWS"))]
36    pub m_worldUpWS: Vector4,
37    /// # C++ Info
38    /// - name: `stringData`(ctype: `struct hkbProjectStringData*`)
39    /// - offset: ` 32`(x86)/` 32`(x86_64)
40    /// - type_size: `  4`(x86)/`  8`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "stringData"))]
42    #[cfg_attr(feature = "serde", serde(rename = "stringData"))]
43    pub m_stringData: Pointer,
44    /// # C++ Info
45    /// - name: `defaultEventMode`(ctype: `enum EventMode`)
46    /// - offset: ` 36`(x86)/` 40`(x86_64)
47    /// - type_size: `  1`(x86)/`  1`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "defaultEventMode"))]
49    #[cfg_attr(feature = "serde", serde(rename = "defaultEventMode"))]
50    pub m_defaultEventMode: EventMode,
51}
52const _: () = {
53    use havok_serde as _serde;
54    impl _serde::HavokClass for hkbProjectData {
55        #[inline]
56        fn name(&self) -> &'static str {
57            "hkbProjectData"
58        }
59        #[inline]
60        fn signature(&self) -> _serde::__private::Signature {
61            _serde::__private::Signature::new(0x13a39ba7)
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.push(self.m_stringData.get());
67            v
68        }
69    }
70    impl _serde::Serialize for hkbProjectData {
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(0x13a39ba7)));
78            let mut serializer = __serializer
79                .serialize_struct("hkbProjectData", class_meta, (48u64, 48u64))?;
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("worldUpWS", &self.m_worldUpWS)?;
86            serializer.serialize_field("stringData", &self.m_stringData)?;
87            serializer.serialize_field("defaultEventMode", &self.m_defaultEventMode)?;
88            serializer.pad_field([0u8; 11usize].as_slice(), [0u8; 7usize].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 hkbProjectData {
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_worldUpWS,
106                m_stringData,
107                m_defaultEventMode,
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                        "worldUpWS" => Ok(__Field::m_worldUpWS),
132                        "stringData" => Ok(__Field::m_stringData),
133                        "defaultEventMode" => Ok(__Field::m_defaultEventMode),
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 __hkbProjectDataVisitor<'de> {
150                marker: _serde::__private::PhantomData<hkbProjectData>,
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 __hkbProjectDataVisitor<'de> {
157                type Value = hkbProjectData;
158                fn expecting(
159                    &self,
160                    __formatter: &mut core::fmt::Formatter,
161                ) -> core::fmt::Result {
162                    core::fmt::Formatter::write_str(__formatter, "struct hkbProjectData")
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_worldUpWS: _serde::__private::Option<Vector4> = _serde::__private::None;
174                    let mut m_stringData: _serde::__private::Option<Pointer> = _serde::__private::None;
175                    let mut m_defaultEventMode: _serde::__private::Option<EventMode> = _serde::__private::None;
176                    for i in 0..3usize {
177                        match i {
178                            0usize => {
179                                if _serde::__private::Option::is_some(&m_worldUpWS) {
180                                    return _serde::__private::Err(
181                                        <__A::Error as _serde::de::Error>::duplicate_field(
182                                            "worldUpWS",
183                                        ),
184                                    );
185                                }
186                                __A::pad(&mut __map, 8usize, 0usize)?;
187                                m_worldUpWS = _serde::__private::Some(
188                                    match __A::next_value::<Vector4>(&mut __map) {
189                                        _serde::__private::Ok(__val) => __val,
190                                        _serde::__private::Err(__err) => {
191                                            return _serde::__private::Err(__err);
192                                        }
193                                    },
194                                );
195                            }
196                            1usize => {
197                                if _serde::__private::Option::is_some(&m_stringData) {
198                                    return _serde::__private::Err(
199                                        <__A::Error as _serde::de::Error>::duplicate_field(
200                                            "stringData",
201                                        ),
202                                    );
203                                }
204                                m_stringData = _serde::__private::Some(
205                                    match __A::next_value::<Pointer>(&mut __map) {
206                                        _serde::__private::Ok(__val) => __val,
207                                        _serde::__private::Err(__err) => {
208                                            return _serde::__private::Err(__err);
209                                        }
210                                    },
211                                );
212                            }
213                            2usize => {
214                                if _serde::__private::Option::is_some(&m_defaultEventMode) {
215                                    return _serde::__private::Err(
216                                        <__A::Error as _serde::de::Error>::duplicate_field(
217                                            "defaultEventMode",
218                                        ),
219                                    );
220                                }
221                                m_defaultEventMode = _serde::__private::Some(
222                                    match __A::next_value::<EventMode>(&mut __map) {
223                                        _serde::__private::Ok(__val) => __val,
224                                        _serde::__private::Err(__err) => {
225                                            return _serde::__private::Err(__err);
226                                        }
227                                    },
228                                );
229                            }
230                            _ => {}
231                        }
232                    }
233                    __A::pad(&mut __map, 11usize, 7usize)?;
234                    let m_worldUpWS = match m_worldUpWS {
235                        _serde::__private::Some(__field) => __field,
236                        _serde::__private::None => {
237                            return _serde::__private::Err(
238                                <__A::Error as _serde::de::Error>::missing_field(
239                                    "worldUpWS",
240                                ),
241                            );
242                        }
243                    };
244                    let m_stringData = match m_stringData {
245                        _serde::__private::Some(__field) => __field,
246                        _serde::__private::None => {
247                            return _serde::__private::Err(
248                                <__A::Error as _serde::de::Error>::missing_field(
249                                    "stringData",
250                                ),
251                            );
252                        }
253                    };
254                    let m_defaultEventMode = match m_defaultEventMode {
255                        _serde::__private::Some(__field) => __field,
256                        _serde::__private::None => {
257                            return _serde::__private::Err(
258                                <__A::Error as _serde::de::Error>::missing_field(
259                                    "defaultEventMode",
260                                ),
261                            );
262                        }
263                    };
264                    _serde::__private::Ok(hkbProjectData {
265                        __ptr,
266                        parent,
267                        m_worldUpWS,
268                        m_stringData,
269                        m_defaultEventMode,
270                    })
271                }
272                #[allow(clippy::manual_unwrap_or_default)]
273                fn visit_struct<__A>(
274                    self,
275                    mut __map: __A,
276                ) -> _serde::__private::Result<Self::Value, __A::Error>
277                where
278                    __A: _serde::de::MapAccess<'de>,
279                {
280                    let mut m_worldUpWS: _serde::__private::Option<Vector4> = _serde::__private::None;
281                    let mut m_stringData: _serde::__private::Option<Pointer> = _serde::__private::None;
282                    let mut m_defaultEventMode: _serde::__private::Option<EventMode> = _serde::__private::None;
283                    while let _serde::__private::Some(__key) = {
284                        __A::next_key::<__Field>(&mut __map)?
285                    } {
286                        match __key {
287                            __Field::m_worldUpWS => {
288                                #[cfg(
289                                    any(feature = "strict", feature = "ignore_duplicates")
290                                )]
291                                if _serde::__private::Option::is_some(&m_worldUpWS) {
292                                    #[cfg(feature = "ignore_duplicates")]
293                                    {
294                                        __A::skip_value(&mut __map)?;
295                                        continue;
296                                    }
297                                    #[cfg(feature = "strict")]
298                                    return _serde::__private::Err(
299                                        <__A::Error as _serde::de::Error>::duplicate_field(
300                                            "worldUpWS",
301                                        ),
302                                    );
303                                }
304                                m_worldUpWS = _serde::__private::Some(
305                                    match __A::next_value::<Vector4>(&mut __map) {
306                                        _serde::__private::Ok(__val) => __val,
307                                        _serde::__private::Err(__err) => {
308                                            return _serde::__private::Err(__err);
309                                        }
310                                    },
311                                );
312                            }
313                            __Field::m_stringData => {
314                                #[cfg(
315                                    any(feature = "strict", feature = "ignore_duplicates")
316                                )]
317                                if _serde::__private::Option::is_some(&m_stringData) {
318                                    #[cfg(feature = "ignore_duplicates")]
319                                    {
320                                        __A::skip_value(&mut __map)?;
321                                        continue;
322                                    }
323                                    #[cfg(feature = "strict")]
324                                    return _serde::__private::Err(
325                                        <__A::Error as _serde::de::Error>::duplicate_field(
326                                            "stringData",
327                                        ),
328                                    );
329                                }
330                                m_stringData = _serde::__private::Some(
331                                    match __A::next_value::<Pointer>(&mut __map) {
332                                        _serde::__private::Ok(__val) => __val,
333                                        _serde::__private::Err(__err) => {
334                                            return _serde::__private::Err(__err);
335                                        }
336                                    },
337                                );
338                            }
339                            __Field::m_defaultEventMode => {
340                                #[cfg(
341                                    any(feature = "strict", feature = "ignore_duplicates")
342                                )]
343                                if _serde::__private::Option::is_some(&m_defaultEventMode) {
344                                    #[cfg(feature = "ignore_duplicates")]
345                                    {
346                                        __A::skip_value(&mut __map)?;
347                                        continue;
348                                    }
349                                    #[cfg(feature = "strict")]
350                                    return _serde::__private::Err(
351                                        <__A::Error as _serde::de::Error>::duplicate_field(
352                                            "defaultEventMode",
353                                        ),
354                                    );
355                                }
356                                m_defaultEventMode = _serde::__private::Some(
357                                    match __A::next_value::<EventMode>(&mut __map) {
358                                        _serde::__private::Ok(__val) => __val,
359                                        _serde::__private::Err(__err) => {
360                                            return _serde::__private::Err(__err);
361                                        }
362                                    },
363                                );
364                            }
365                            _ => __A::skip_value(&mut __map)?,
366                        }
367                    }
368                    let m_worldUpWS = match m_worldUpWS {
369                        _serde::__private::Some(__field) => __field,
370                        _serde::__private::None => {
371                            #[cfg(feature = "strict")]
372                            return _serde::__private::Err(
373                                <__A::Error as _serde::de::Error>::missing_field(
374                                    "worldUpWS",
375                                ),
376                            );
377                            #[cfg(not(feature = "strict"))] Default::default()
378                        }
379                    };
380                    let m_stringData = match m_stringData {
381                        _serde::__private::Some(__field) => __field,
382                        _serde::__private::None => {
383                            #[cfg(feature = "strict")]
384                            return _serde::__private::Err(
385                                <__A::Error as _serde::de::Error>::missing_field(
386                                    "stringData",
387                                ),
388                            );
389                            #[cfg(not(feature = "strict"))] Default::default()
390                        }
391                    };
392                    let m_defaultEventMode = match m_defaultEventMode {
393                        _serde::__private::Some(__field) => __field,
394                        _serde::__private::None => {
395                            #[cfg(feature = "strict")]
396                            return _serde::__private::Err(
397                                <__A::Error as _serde::de::Error>::missing_field(
398                                    "defaultEventMode",
399                                ),
400                            );
401                            #[cfg(not(feature = "strict"))] Default::default()
402                        }
403                    };
404                    let __ptr = None;
405                    let parent = hkBaseObject { __ptr };
406                    let parent = hkReferencedObject {
407                        __ptr,
408                        parent,
409                        ..Default::default()
410                    };
411                    let __ptr = __A::class_ptr(&mut __map);
412                    _serde::__private::Ok(hkbProjectData {
413                        __ptr,
414                        parent,
415                        m_worldUpWS,
416                        m_stringData,
417                        m_defaultEventMode,
418                    })
419                }
420            }
421            const FIELDS: &[&str] = &["worldUpWS", "stringData", "defaultEventMode"];
422            _serde::Deserializer::deserialize_struct(
423                deserializer,
424                "hkbProjectData",
425                FIELDS,
426                __hkbProjectDataVisitor {
427                    marker: _serde::__private::PhantomData::<hkbProjectData>,
428                    lifetime: _serde::__private::PhantomData,
429                },
430            )
431        }
432    }
433};
havok_classes/generated/hkbProjectData_.rs

havok_classes/generated/
hkbProjectData_.rs
