havok_classes/generated/
hkbExtractRagdollPoseModifier_.rs

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