havok_classes/generated/
hkbKeyframeBonesModifier_.rs

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