havok_classes/generated/
hkbHandle_.rs

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

havok_classes/generated/
hkbHandle_.rs
