havok_classes/generated/
hkbPoweredRagdollControlsModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbPoweredRagdollControlsModifier`
5/// - version: `5`
6/// - signature: `0x7cb54065`
7/// - size: ` 96`(x86)/`144`(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 hkbPoweredRagdollControlsModifier<'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 hkbPoweredRagdollControlData`)
33    /// - offset: ` 48`(x86)/` 80`(x86_64)
34    /// - type_size: ` 32`(x86)/` 32`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "controlData"))]
36    #[cfg_attr(feature = "serde", serde(rename = "controlData"))]
37    pub m_controlData: hkbPoweredRagdollControlData,
38    /// # C++ Info
39    /// - name: `bones`(ctype: `struct hkbBoneIndexArray*`)
40    /// - offset: ` 80`(x86)/`112`(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    /// # C++ Info
46    /// - name: `worldFromModelModeData`(ctype: `struct hkbWorldFromModelModeData`)
47    /// - offset: ` 84`(x86)/`120`(x86_64)
48    /// - type_size: `  8`(x86)/`  8`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "worldFromModelModeData"))]
50    #[cfg_attr(feature = "serde", serde(rename = "worldFromModelModeData"))]
51    pub m_worldFromModelModeData: hkbWorldFromModelModeData,
52    /// # C++ Info
53    /// - name: `boneWeights`(ctype: `struct hkbBoneWeightArray*`)
54    /// - offset: ` 92`(x86)/`128`(x86_64)
55    /// - type_size: `  4`(x86)/`  8`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "boneWeights"))]
57    #[cfg_attr(feature = "serde", serde(rename = "boneWeights"))]
58    pub m_boneWeights: Pointer,
59}
60const _: () = {
61    use havok_serde as _serde;
62    impl<'a> _serde::HavokClass for hkbPoweredRagdollControlsModifier<'a> {
63        #[inline]
64        fn name(&self) -> &'static str {
65            "hkbPoweredRagdollControlsModifier"
66        }
67        #[inline]
68        fn signature(&self) -> _serde::__private::Signature {
69            _serde::__private::Signature::new(0x7cb54065)
70        }
71        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
72        fn deps_indexes(&self) -> Vec<usize> {
73            let mut v = Vec::new();
74            v.push(self.parent.parent.parent.m_variableBindingSet.get());
75            v.extend(self.m_controlData.deps_indexes());
76            v.push(self.m_bones.get());
77            v.extend(self.m_worldFromModelModeData.deps_indexes());
78            v.push(self.m_boneWeights.get());
79            v
80        }
81    }
82    impl<'a> _serde::Serialize for hkbPoweredRagdollControlsModifier<'a> {
83        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
84        where
85            S: _serde::ser::Serializer,
86        {
87            let class_meta = self
88                .__ptr
89                .map(|name| (name, _serde::__private::Signature::new(0x7cb54065)));
90            let mut serializer = __serializer
91                .serialize_struct(
92                    "hkbPoweredRagdollControlsModifier",
93                    class_meta,
94                    (96u64, 144u64),
95                )?;
96            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
97            serializer
98                .skip_field(
99                    "memSizeAndFlags",
100                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
101                )?;
102            serializer
103                .skip_field(
104                    "referenceCount",
105                    &self.parent.parent.parent.parent.m_referenceCount,
106                )?;
107            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
108            serializer
109                .serialize_field(
110                    "variableBindingSet",
111                    &self.parent.parent.parent.m_variableBindingSet,
112                )?;
113            serializer
114                .skip_array_field(
115                    "cachedBindables",
116                    &self.parent.parent.parent.m_cachedBindables,
117                    TypeSize::NonPtr,
118                )?;
119            serializer
120                .skip_field(
121                    "areBindablesCached",
122                    &self.parent.parent.parent.m_areBindablesCached,
123                )?;
124            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
125            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
126            serializer.serialize_field("name", &self.parent.parent.m_name)?;
127            serializer.skip_field("id", &self.parent.parent.m_id)?;
128            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
129            serializer
130                .skip_fixed_array_field(
131                    "padNode",
132                    self.parent.parent.m_padNode.as_slice(),
133                    TypeSize::NonPtr,
134                )?;
135            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
136            serializer.serialize_field("enable", &self.parent.m_enable)?;
137            serializer
138                .skip_fixed_array_field(
139                    "padModifier",
140                    self.parent.m_padModifier.as_slice(),
141                    TypeSize::NonPtr,
142                )?;
143            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
144            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
145            serializer.serialize_field("controlData", &self.m_controlData)?;
146            serializer.serialize_field("bones", &self.m_bones)?;
147            serializer
148                .serialize_field(
149                    "worldFromModelModeData",
150                    &self.m_worldFromModelModeData,
151                )?;
152            serializer.serialize_field("boneWeights", &self.m_boneWeights)?;
153            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 8usize].as_slice())?;
154            serializer.end()
155        }
156    }
157};
158#[doc(hidden)]
159#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
160const _: () = {
161    use havok_serde as _serde;
162    #[automatically_derived]
163    impl<'de> _serde::Deserialize<'de> for hkbPoweredRagdollControlsModifier<'de> {
164        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
165        where
166            __D: _serde::Deserializer<'de>,
167        {
168            #[allow(non_camel_case_types)]
169            enum __Field {
170                m_variableBindingSet,
171                m_userData,
172                m_name,
173                m_enable,
174                m_controlData,
175                m_bones,
176                m_worldFromModelModeData,
177                m_boneWeights,
178                __ignore,
179            }
180            struct __FieldVisitor;
181            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
182                type Value = __Field;
183                fn expecting(
184                    &self,
185                    __formatter: &mut core::fmt::Formatter,
186                ) -> core::fmt::Result {
187                    core::fmt::Formatter::write_str(__formatter, "field identifier")
188                }
189                /// Intended for use in XML.
190                #[allow(clippy::match_single_binding)]
191                #[allow(clippy::reversed_empty_ranges)]
192                #[allow(clippy::single_match)]
193                fn visit_key<__E>(
194                    self,
195                    __value: &str,
196                ) -> core::result::Result<Self::Value, __E>
197                where
198                    __E: _serde::de::Error,
199                {
200                    match __value {
201                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
202                        "userData" => Ok(__Field::m_userData),
203                        "name" => Ok(__Field::m_name),
204                        "enable" => Ok(__Field::m_enable),
205                        "controlData" => Ok(__Field::m_controlData),
206                        "bones" => Ok(__Field::m_bones),
207                        "worldFromModelModeData" => Ok(__Field::m_worldFromModelModeData),
208                        "boneWeights" => Ok(__Field::m_boneWeights),
209                        _ => Ok(__Field::__ignore),
210                    }
211                }
212            }
213            impl<'de> _serde::Deserialize<'de> for __Field {
214                #[inline]
215                fn deserialize<__D>(
216                    __deserializer: __D,
217                ) -> core::result::Result<Self, __D::Error>
218                where
219                    __D: _serde::Deserializer<'de>,
220                {
221                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
222                }
223            }
224            struct __hkbPoweredRagdollControlsModifierVisitor<'de> {
225                marker: _serde::__private::PhantomData<
226                    hkbPoweredRagdollControlsModifier<'de>,
227                >,
228                lifetime: _serde::__private::PhantomData<&'de ()>,
229            }
230            #[allow(clippy::match_single_binding)]
231            #[allow(clippy::reversed_empty_ranges)]
232            #[allow(clippy::single_match)]
233            impl<'de> _serde::de::Visitor<'de>
234            for __hkbPoweredRagdollControlsModifierVisitor<'de> {
235                type Value = hkbPoweredRagdollControlsModifier<'de>;
236                fn expecting(
237                    &self,
238                    __formatter: &mut core::fmt::Formatter,
239                ) -> core::fmt::Result {
240                    core::fmt::Formatter::write_str(
241                        __formatter,
242                        "struct hkbPoweredRagdollControlsModifier",
243                    )
244                }
245                fn visit_struct_for_bytes<__A>(
246                    self,
247                    mut __map: __A,
248                ) -> _serde::__private::Result<Self::Value, __A::Error>
249                where
250                    __A: _serde::de::MapAccess<'de>,
251                {
252                    let __ptr = __A::class_ptr(&mut __map);
253                    let parent = __A::parent_value(&mut __map)?;
254                    let mut m_controlData: _serde::__private::Option<
255                        hkbPoweredRagdollControlData,
256                    > = _serde::__private::None;
257                    let mut m_bones: _serde::__private::Option<Pointer> = _serde::__private::None;
258                    let mut m_worldFromModelModeData: _serde::__private::Option<
259                        hkbWorldFromModelModeData,
260                    > = _serde::__private::None;
261                    let mut m_boneWeights: _serde::__private::Option<Pointer> = _serde::__private::None;
262                    for i in 0..4usize {
263                        match i {
264                            0usize => {
265                                if _serde::__private::Option::is_some(&m_controlData) {
266                                    return _serde::__private::Err(
267                                        <__A::Error as _serde::de::Error>::duplicate_field(
268                                            "controlData",
269                                        ),
270                                    );
271                                }
272                                __A::pad(&mut __map, 4usize, 0usize)?;
273                                m_controlData = _serde::__private::Some(
274                                    match __A::next_value::<
275                                        hkbPoweredRagdollControlData,
276                                    >(&mut __map) {
277                                        _serde::__private::Ok(__val) => __val,
278                                        _serde::__private::Err(__err) => {
279                                            return _serde::__private::Err(__err);
280                                        }
281                                    },
282                                );
283                            }
284                            1usize => {
285                                if _serde::__private::Option::is_some(&m_bones) {
286                                    return _serde::__private::Err(
287                                        <__A::Error as _serde::de::Error>::duplicate_field("bones"),
288                                    );
289                                }
290                                m_bones = _serde::__private::Some(
291                                    match __A::next_value::<Pointer>(&mut __map) {
292                                        _serde::__private::Ok(__val) => __val,
293                                        _serde::__private::Err(__err) => {
294                                            return _serde::__private::Err(__err);
295                                        }
296                                    },
297                                );
298                            }
299                            2usize => {
300                                if _serde::__private::Option::is_some(
301                                    &m_worldFromModelModeData,
302                                ) {
303                                    return _serde::__private::Err(
304                                        <__A::Error as _serde::de::Error>::duplicate_field(
305                                            "worldFromModelModeData",
306                                        ),
307                                    );
308                                }
309                                m_worldFromModelModeData = _serde::__private::Some(
310                                    match __A::next_value::<
311                                        hkbWorldFromModelModeData,
312                                    >(&mut __map) {
313                                        _serde::__private::Ok(__val) => __val,
314                                        _serde::__private::Err(__err) => {
315                                            return _serde::__private::Err(__err);
316                                        }
317                                    },
318                                );
319                            }
320                            3usize => {
321                                if _serde::__private::Option::is_some(&m_boneWeights) {
322                                    return _serde::__private::Err(
323                                        <__A::Error as _serde::de::Error>::duplicate_field(
324                                            "boneWeights",
325                                        ),
326                                    );
327                                }
328                                m_boneWeights = _serde::__private::Some(
329                                    match __A::next_value::<Pointer>(&mut __map) {
330                                        _serde::__private::Ok(__val) => __val,
331                                        _serde::__private::Err(__err) => {
332                                            return _serde::__private::Err(__err);
333                                        }
334                                    },
335                                );
336                            }
337                            _ => {}
338                        }
339                    }
340                    __A::pad(&mut __map, 0usize, 8usize)?;
341                    let m_controlData = match m_controlData {
342                        _serde::__private::Some(__field) => __field,
343                        _serde::__private::None => {
344                            return _serde::__private::Err(
345                                <__A::Error as _serde::de::Error>::missing_field(
346                                    "controlData",
347                                ),
348                            );
349                        }
350                    };
351                    let m_bones = match m_bones {
352                        _serde::__private::Some(__field) => __field,
353                        _serde::__private::None => {
354                            return _serde::__private::Err(
355                                <__A::Error as _serde::de::Error>::missing_field("bones"),
356                            );
357                        }
358                    };
359                    let m_worldFromModelModeData = match m_worldFromModelModeData {
360                        _serde::__private::Some(__field) => __field,
361                        _serde::__private::None => {
362                            return _serde::__private::Err(
363                                <__A::Error as _serde::de::Error>::missing_field(
364                                    "worldFromModelModeData",
365                                ),
366                            );
367                        }
368                    };
369                    let m_boneWeights = match m_boneWeights {
370                        _serde::__private::Some(__field) => __field,
371                        _serde::__private::None => {
372                            return _serde::__private::Err(
373                                <__A::Error as _serde::de::Error>::missing_field(
374                                    "boneWeights",
375                                ),
376                            );
377                        }
378                    };
379                    _serde::__private::Ok(hkbPoweredRagdollControlsModifier {
380                        __ptr,
381                        parent,
382                        m_controlData,
383                        m_bones,
384                        m_worldFromModelModeData,
385                        m_boneWeights,
386                    })
387                }
388                #[allow(clippy::manual_unwrap_or_default)]
389                fn visit_struct<__A>(
390                    self,
391                    mut __map: __A,
392                ) -> _serde::__private::Result<Self::Value, __A::Error>
393                where
394                    __A: _serde::de::MapAccess<'de>,
395                {
396                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
397                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
398                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
399                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
400                    let mut m_controlData: _serde::__private::Option<
401                        hkbPoweredRagdollControlData,
402                    > = _serde::__private::None;
403                    let mut m_bones: _serde::__private::Option<Pointer> = _serde::__private::None;
404                    let mut m_worldFromModelModeData: _serde::__private::Option<
405                        hkbWorldFromModelModeData,
406                    > = _serde::__private::None;
407                    let mut m_boneWeights: _serde::__private::Option<Pointer> = _serde::__private::None;
408                    while let _serde::__private::Some(__key) = {
409                        __A::next_key::<__Field>(&mut __map)?
410                    } {
411                        match __key {
412                            __Field::m_variableBindingSet => {
413                                #[cfg(
414                                    any(feature = "strict", feature = "ignore_duplicates")
415                                )]
416                                if _serde::__private::Option::is_some(
417                                    &m_variableBindingSet,
418                                ) {
419                                    #[cfg(feature = "ignore_duplicates")]
420                                    {
421                                        __A::skip_value(&mut __map)?;
422                                        continue;
423                                    }
424                                    #[cfg(feature = "strict")]
425                                    return _serde::__private::Err(
426                                        <__A::Error as _serde::de::Error>::duplicate_field(
427                                            "variableBindingSet",
428                                        ),
429                                    );
430                                }
431                                m_variableBindingSet = _serde::__private::Some(
432                                    match __A::next_value::<Pointer>(&mut __map) {
433                                        _serde::__private::Ok(__val) => __val,
434                                        _serde::__private::Err(__err) => {
435                                            return _serde::__private::Err(__err);
436                                        }
437                                    },
438                                );
439                            }
440                            __Field::m_userData => {
441                                #[cfg(
442                                    any(feature = "strict", feature = "ignore_duplicates")
443                                )]
444                                if _serde::__private::Option::is_some(&m_userData) {
445                                    #[cfg(feature = "ignore_duplicates")]
446                                    {
447                                        __A::skip_value(&mut __map)?;
448                                        continue;
449                                    }
450                                    #[cfg(feature = "strict")]
451                                    return _serde::__private::Err(
452                                        <__A::Error as _serde::de::Error>::duplicate_field(
453                                            "userData",
454                                        ),
455                                    );
456                                }
457                                m_userData = _serde::__private::Some(
458                                    match __A::next_value::<Ulong>(&mut __map) {
459                                        _serde::__private::Ok(__val) => __val,
460                                        _serde::__private::Err(__err) => {
461                                            return _serde::__private::Err(__err);
462                                        }
463                                    },
464                                );
465                            }
466                            __Field::m_name => {
467                                #[cfg(
468                                    any(feature = "strict", feature = "ignore_duplicates")
469                                )]
470                                if _serde::__private::Option::is_some(&m_name) {
471                                    #[cfg(feature = "ignore_duplicates")]
472                                    {
473                                        __A::skip_value(&mut __map)?;
474                                        continue;
475                                    }
476                                    #[cfg(feature = "strict")]
477                                    return _serde::__private::Err(
478                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
479                                    );
480                                }
481                                m_name = _serde::__private::Some(
482                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
483                                        _serde::__private::Ok(__val) => __val,
484                                        _serde::__private::Err(__err) => {
485                                            return _serde::__private::Err(__err);
486                                        }
487                                    },
488                                );
489                            }
490                            __Field::m_enable => {
491                                #[cfg(
492                                    any(feature = "strict", feature = "ignore_duplicates")
493                                )]
494                                if _serde::__private::Option::is_some(&m_enable) {
495                                    #[cfg(feature = "ignore_duplicates")]
496                                    {
497                                        __A::skip_value(&mut __map)?;
498                                        continue;
499                                    }
500                                    #[cfg(feature = "strict")]
501                                    return _serde::__private::Err(
502                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
503                                    );
504                                }
505                                m_enable = _serde::__private::Some(
506                                    match __A::next_value::<bool>(&mut __map) {
507                                        _serde::__private::Ok(__val) => __val,
508                                        _serde::__private::Err(__err) => {
509                                            return _serde::__private::Err(__err);
510                                        }
511                                    },
512                                );
513                            }
514                            __Field::m_controlData => {
515                                #[cfg(
516                                    any(feature = "strict", feature = "ignore_duplicates")
517                                )]
518                                if _serde::__private::Option::is_some(&m_controlData) {
519                                    #[cfg(feature = "ignore_duplicates")]
520                                    {
521                                        __A::skip_value(&mut __map)?;
522                                        continue;
523                                    }
524                                    #[cfg(feature = "strict")]
525                                    return _serde::__private::Err(
526                                        <__A::Error as _serde::de::Error>::duplicate_field(
527                                            "controlData",
528                                        ),
529                                    );
530                                }
531                                m_controlData = _serde::__private::Some(
532                                    match __A::next_value::<
533                                        hkbPoweredRagdollControlData,
534                                    >(&mut __map) {
535                                        _serde::__private::Ok(__val) => __val,
536                                        _serde::__private::Err(__err) => {
537                                            return _serde::__private::Err(__err);
538                                        }
539                                    },
540                                );
541                            }
542                            __Field::m_bones => {
543                                #[cfg(
544                                    any(feature = "strict", feature = "ignore_duplicates")
545                                )]
546                                if _serde::__private::Option::is_some(&m_bones) {
547                                    #[cfg(feature = "ignore_duplicates")]
548                                    {
549                                        __A::skip_value(&mut __map)?;
550                                        continue;
551                                    }
552                                    #[cfg(feature = "strict")]
553                                    return _serde::__private::Err(
554                                        <__A::Error as _serde::de::Error>::duplicate_field("bones"),
555                                    );
556                                }
557                                m_bones = _serde::__private::Some(
558                                    match __A::next_value::<Pointer>(&mut __map) {
559                                        _serde::__private::Ok(__val) => __val,
560                                        _serde::__private::Err(__err) => {
561                                            return _serde::__private::Err(__err);
562                                        }
563                                    },
564                                );
565                            }
566                            __Field::m_worldFromModelModeData => {
567                                #[cfg(
568                                    any(feature = "strict", feature = "ignore_duplicates")
569                                )]
570                                if _serde::__private::Option::is_some(
571                                    &m_worldFromModelModeData,
572                                ) {
573                                    #[cfg(feature = "ignore_duplicates")]
574                                    {
575                                        __A::skip_value(&mut __map)?;
576                                        continue;
577                                    }
578                                    #[cfg(feature = "strict")]
579                                    return _serde::__private::Err(
580                                        <__A::Error as _serde::de::Error>::duplicate_field(
581                                            "worldFromModelModeData",
582                                        ),
583                                    );
584                                }
585                                m_worldFromModelModeData = _serde::__private::Some(
586                                    match __A::next_value::<
587                                        hkbWorldFromModelModeData,
588                                    >(&mut __map) {
589                                        _serde::__private::Ok(__val) => __val,
590                                        _serde::__private::Err(__err) => {
591                                            return _serde::__private::Err(__err);
592                                        }
593                                    },
594                                );
595                            }
596                            __Field::m_boneWeights => {
597                                #[cfg(
598                                    any(feature = "strict", feature = "ignore_duplicates")
599                                )]
600                                if _serde::__private::Option::is_some(&m_boneWeights) {
601                                    #[cfg(feature = "ignore_duplicates")]
602                                    {
603                                        __A::skip_value(&mut __map)?;
604                                        continue;
605                                    }
606                                    #[cfg(feature = "strict")]
607                                    return _serde::__private::Err(
608                                        <__A::Error as _serde::de::Error>::duplicate_field(
609                                            "boneWeights",
610                                        ),
611                                    );
612                                }
613                                m_boneWeights = _serde::__private::Some(
614                                    match __A::next_value::<Pointer>(&mut __map) {
615                                        _serde::__private::Ok(__val) => __val,
616                                        _serde::__private::Err(__err) => {
617                                            return _serde::__private::Err(__err);
618                                        }
619                                    },
620                                );
621                            }
622                            _ => __A::skip_value(&mut __map)?,
623                        }
624                    }
625                    let m_variableBindingSet = match m_variableBindingSet {
626                        _serde::__private::Some(__field) => __field,
627                        _serde::__private::None => {
628                            #[cfg(feature = "strict")]
629                            return _serde::__private::Err(
630                                <__A::Error as _serde::de::Error>::missing_field(
631                                    "variableBindingSet",
632                                ),
633                            );
634                            #[cfg(not(feature = "strict"))] Default::default()
635                        }
636                    };
637                    let m_userData = match m_userData {
638                        _serde::__private::Some(__field) => __field,
639                        _serde::__private::None => {
640                            #[cfg(feature = "strict")]
641                            return _serde::__private::Err(
642                                <__A::Error as _serde::de::Error>::missing_field("userData"),
643                            );
644                            #[cfg(not(feature = "strict"))] Default::default()
645                        }
646                    };
647                    let m_name = match m_name {
648                        _serde::__private::Some(__field) => __field,
649                        _serde::__private::None => {
650                            #[cfg(feature = "strict")]
651                            return _serde::__private::Err(
652                                <__A::Error as _serde::de::Error>::missing_field("name"),
653                            );
654                            #[cfg(not(feature = "strict"))] Default::default()
655                        }
656                    };
657                    let m_enable = match m_enable {
658                        _serde::__private::Some(__field) => __field,
659                        _serde::__private::None => {
660                            #[cfg(feature = "strict")]
661                            return _serde::__private::Err(
662                                <__A::Error as _serde::de::Error>::missing_field("enable"),
663                            );
664                            #[cfg(not(feature = "strict"))] Default::default()
665                        }
666                    };
667                    let m_controlData = match m_controlData {
668                        _serde::__private::Some(__field) => __field,
669                        _serde::__private::None => {
670                            #[cfg(feature = "strict")]
671                            return _serde::__private::Err(
672                                <__A::Error as _serde::de::Error>::missing_field(
673                                    "controlData",
674                                ),
675                            );
676                            #[cfg(not(feature = "strict"))] Default::default()
677                        }
678                    };
679                    let m_bones = match m_bones {
680                        _serde::__private::Some(__field) => __field,
681                        _serde::__private::None => {
682                            #[cfg(feature = "strict")]
683                            return _serde::__private::Err(
684                                <__A::Error as _serde::de::Error>::missing_field("bones"),
685                            );
686                            #[cfg(not(feature = "strict"))] Default::default()
687                        }
688                    };
689                    let m_worldFromModelModeData = match m_worldFromModelModeData {
690                        _serde::__private::Some(__field) => __field,
691                        _serde::__private::None => {
692                            #[cfg(feature = "strict")]
693                            return _serde::__private::Err(
694                                <__A::Error as _serde::de::Error>::missing_field(
695                                    "worldFromModelModeData",
696                                ),
697                            );
698                            #[cfg(not(feature = "strict"))] Default::default()
699                        }
700                    };
701                    let m_boneWeights = match m_boneWeights {
702                        _serde::__private::Some(__field) => __field,
703                        _serde::__private::None => {
704                            #[cfg(feature = "strict")]
705                            return _serde::__private::Err(
706                                <__A::Error as _serde::de::Error>::missing_field(
707                                    "boneWeights",
708                                ),
709                            );
710                            #[cfg(not(feature = "strict"))] Default::default()
711                        }
712                    };
713                    let __ptr = None;
714                    let parent = hkBaseObject { __ptr };
715                    let parent = hkReferencedObject {
716                        __ptr,
717                        parent,
718                        ..Default::default()
719                    };
720                    let parent = hkbBindable {
721                        __ptr,
722                        parent,
723                        m_variableBindingSet,
724                        ..Default::default()
725                    };
726                    let parent = hkbNode {
727                        __ptr,
728                        parent,
729                        m_userData,
730                        m_name,
731                        ..Default::default()
732                    };
733                    let parent = hkbModifier {
734                        __ptr,
735                        parent,
736                        m_enable,
737                        ..Default::default()
738                    };
739                    let __ptr = __A::class_ptr(&mut __map);
740                    _serde::__private::Ok(hkbPoweredRagdollControlsModifier {
741                        __ptr,
742                        parent,
743                        m_controlData,
744                        m_bones,
745                        m_worldFromModelModeData,
746                        m_boneWeights,
747                    })
748                }
749            }
750            const FIELDS: &[&str] = &[
751                "controlData",
752                "bones",
753                "worldFromModelModeData",
754                "boneWeights",
755            ];
756            _serde::Deserializer::deserialize_struct(
757                deserializer,
758                "hkbPoweredRagdollControlsModifier",
759                FIELDS,
760                __hkbPoweredRagdollControlsModifierVisitor {
761                    marker: _serde::__private::PhantomData::<
762                        hkbPoweredRagdollControlsModifier,
763                    >,
764                    lifetime: _serde::__private::PhantomData,
765                },
766            )
767        }
768    }
769};