havok_classes/generated/
hkbRigidBodyRagdollControlsModifier_.rs

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

havok_classes/generated/
hkbRigidBodyRagdollControlsModifier_.rs
