havok_classes/generated/
hkbCharacterSteppedInfo_.rs

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