havok_classes/generated/
hkaDefaultAnimatedReferenceFrame_.rs

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

havok_classes/generated/
hkaDefaultAnimatedReferenceFrame_.rs
