havok_classes/generated/
hkbHandIkControlsModifier_.rs

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