havok_classes/generated/
hkbHandIkModifierHand_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbHandIkModifierHand`
5/// - version: `3`
6/// - signature: `0x14dfe1dd`
7/// - size: ` 96`(x86)/` 96`(x86_64)
8/// -  vtable: `false`
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 hkbHandIkModifierHand<'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    /// # C++ Info
27    /// - name: `elbowAxisLS`(ctype: `hkVector4`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 16`(x86)/` 16`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "elbowAxisLS"))]
31    #[cfg_attr(feature = "serde", serde(rename = "elbowAxisLS"))]
32    pub m_elbowAxisLS: Vector4,
33    /// # C++ Info
34    /// - name: `backHandNormalLS`(ctype: `hkVector4`)
35    /// - offset: ` 16`(x86)/` 16`(x86_64)
36    /// - type_size: ` 16`(x86)/` 16`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "backHandNormalLS"))]
38    #[cfg_attr(feature = "serde", serde(rename = "backHandNormalLS"))]
39    pub m_backHandNormalLS: Vector4,
40    /// # C++ Info
41    /// - name: `handOffsetLS`(ctype: `hkVector4`)
42    /// - offset: ` 32`(x86)/` 32`(x86_64)
43    /// - type_size: ` 16`(x86)/` 16`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "handOffsetLS"))]
45    #[cfg_attr(feature = "serde", serde(rename = "handOffsetLS"))]
46    pub m_handOffsetLS: Vector4,
47    /// # C++ Info
48    /// - name: `handOrienationOffsetLS`(ctype: `hkQuaternion`)
49    /// - offset: ` 48`(x86)/` 48`(x86_64)
50    /// - type_size: ` 16`(x86)/` 16`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "handOrienationOffsetLS"))]
52    #[cfg_attr(feature = "serde", serde(rename = "handOrienationOffsetLS"))]
53    pub m_handOrienationOffsetLS: Quaternion,
54    /// # C++ Info
55    /// - name: `maxElbowAngleDegrees`(ctype: `hkReal`)
56    /// - offset: ` 64`(x86)/` 64`(x86_64)
57    /// - type_size: `  4`(x86)/`  4`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "maxElbowAngleDegrees"))]
59    #[cfg_attr(feature = "serde", serde(rename = "maxElbowAngleDegrees"))]
60    pub m_maxElbowAngleDegrees: f32,
61    /// # C++ Info
62    /// - name: `minElbowAngleDegrees`(ctype: `hkReal`)
63    /// - offset: ` 68`(x86)/` 68`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "minElbowAngleDegrees"))]
66    #[cfg_attr(feature = "serde", serde(rename = "minElbowAngleDegrees"))]
67    pub m_minElbowAngleDegrees: f32,
68    /// # C++ Info
69    /// - name: `shoulderIndex`(ctype: `hkInt16`)
70    /// - offset: ` 72`(x86)/` 72`(x86_64)
71    /// - type_size: `  2`(x86)/`  2`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "shoulderIndex"))]
73    #[cfg_attr(feature = "serde", serde(rename = "shoulderIndex"))]
74    pub m_shoulderIndex: i16,
75    /// # C++ Info
76    /// - name: `shoulderSiblingIndex`(ctype: `hkInt16`)
77    /// - offset: ` 74`(x86)/` 74`(x86_64)
78    /// - type_size: `  2`(x86)/`  2`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "shoulderSiblingIndex"))]
80    #[cfg_attr(feature = "serde", serde(rename = "shoulderSiblingIndex"))]
81    pub m_shoulderSiblingIndex: i16,
82    /// # C++ Info
83    /// - name: `elbowIndex`(ctype: `hkInt16`)
84    /// - offset: ` 76`(x86)/` 76`(x86_64)
85    /// - type_size: `  2`(x86)/`  2`(x86_64)
86    #[cfg_attr(feature = "json_schema", schemars(rename = "elbowIndex"))]
87    #[cfg_attr(feature = "serde", serde(rename = "elbowIndex"))]
88    pub m_elbowIndex: i16,
89    /// # C++ Info
90    /// - name: `elbowSiblingIndex`(ctype: `hkInt16`)
91    /// - offset: ` 78`(x86)/` 78`(x86_64)
92    /// - type_size: `  2`(x86)/`  2`(x86_64)
93    #[cfg_attr(feature = "json_schema", schemars(rename = "elbowSiblingIndex"))]
94    #[cfg_attr(feature = "serde", serde(rename = "elbowSiblingIndex"))]
95    pub m_elbowSiblingIndex: i16,
96    /// # C++ Info
97    /// - name: `wristIndex`(ctype: `hkInt16`)
98    /// - offset: ` 80`(x86)/` 80`(x86_64)
99    /// - type_size: `  2`(x86)/`  2`(x86_64)
100    #[cfg_attr(feature = "json_schema", schemars(rename = "wristIndex"))]
101    #[cfg_attr(feature = "serde", serde(rename = "wristIndex"))]
102    pub m_wristIndex: i16,
103    /// # C++ Info
104    /// - name: `enforceEndPosition`(ctype: `hkBool`)
105    /// - offset: ` 82`(x86)/` 82`(x86_64)
106    /// - type_size: `  1`(x86)/`  1`(x86_64)
107    #[cfg_attr(feature = "json_schema", schemars(rename = "enforceEndPosition"))]
108    #[cfg_attr(feature = "serde", serde(rename = "enforceEndPosition"))]
109    pub m_enforceEndPosition: bool,
110    /// # C++ Info
111    /// - name: `enforceEndRotation`(ctype: `hkBool`)
112    /// - offset: ` 83`(x86)/` 83`(x86_64)
113    /// - type_size: `  1`(x86)/`  1`(x86_64)
114    #[cfg_attr(feature = "json_schema", schemars(rename = "enforceEndRotation"))]
115    #[cfg_attr(feature = "serde", serde(rename = "enforceEndRotation"))]
116    pub m_enforceEndRotation: bool,
117    /// # C++ Info
118    /// - name: `localFrameName`(ctype: `hkStringPtr`)
119    /// - offset: ` 84`(x86)/` 88`(x86_64)
120    /// - type_size: `  4`(x86)/`  8`(x86_64)
121    #[cfg_attr(feature = "serde", serde(borrow))]
122    #[cfg_attr(feature = "json_schema", schemars(rename = "localFrameName"))]
123    #[cfg_attr(feature = "serde", serde(rename = "localFrameName"))]
124    pub m_localFrameName: StringPtr<'a>,
125}
126const _: () = {
127    use havok_serde as _serde;
128    impl<'a> _serde::HavokClass for hkbHandIkModifierHand<'a> {
129        #[inline]
130        fn name(&self) -> &'static str {
131            "hkbHandIkModifierHand"
132        }
133        #[inline]
134        fn signature(&self) -> _serde::__private::Signature {
135            _serde::__private::Signature::new(0x14dfe1dd)
136        }
137        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
138        fn deps_indexes(&self) -> Vec<usize> {
139            let mut v = Vec::new();
140            v
141        }
142    }
143    impl<'a> _serde::Serialize for hkbHandIkModifierHand<'a> {
144        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
145        where
146            S: _serde::ser::Serializer,
147        {
148            let class_meta = self
149                .__ptr
150                .map(|name| (name, _serde::__private::Signature::new(0x14dfe1dd)));
151            let mut serializer = __serializer
152                .serialize_struct("hkbHandIkModifierHand", class_meta, (96u64, 96u64))?;
153            serializer.serialize_field("elbowAxisLS", &self.m_elbowAxisLS)?;
154            serializer.serialize_field("backHandNormalLS", &self.m_backHandNormalLS)?;
155            serializer.serialize_field("handOffsetLS", &self.m_handOffsetLS)?;
156            serializer
157                .serialize_field(
158                    "handOrienationOffsetLS",
159                    &self.m_handOrienationOffsetLS,
160                )?;
161            serializer
162                .serialize_field("maxElbowAngleDegrees", &self.m_maxElbowAngleDegrees)?;
163            serializer
164                .serialize_field("minElbowAngleDegrees", &self.m_minElbowAngleDegrees)?;
165            serializer.serialize_field("shoulderIndex", &self.m_shoulderIndex)?;
166            serializer
167                .serialize_field("shoulderSiblingIndex", &self.m_shoulderSiblingIndex)?;
168            serializer.serialize_field("elbowIndex", &self.m_elbowIndex)?;
169            serializer.serialize_field("elbowSiblingIndex", &self.m_elbowSiblingIndex)?;
170            serializer.serialize_field("wristIndex", &self.m_wristIndex)?;
171            serializer
172                .serialize_field("enforceEndPosition", &self.m_enforceEndPosition)?;
173            serializer
174                .serialize_field("enforceEndRotation", &self.m_enforceEndRotation)?;
175            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
176            serializer.serialize_field("localFrameName", &self.m_localFrameName)?;
177            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
178            serializer.end()
179        }
180    }
181};
182#[doc(hidden)]
183#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
184const _: () = {
185    use havok_serde as _serde;
186    #[automatically_derived]
187    impl<'de> _serde::Deserialize<'de> for hkbHandIkModifierHand<'de> {
188        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
189        where
190            __D: _serde::Deserializer<'de>,
191        {
192            #[allow(non_camel_case_types)]
193            enum __Field {
194                m_elbowAxisLS,
195                m_backHandNormalLS,
196                m_handOffsetLS,
197                m_handOrienationOffsetLS,
198                m_maxElbowAngleDegrees,
199                m_minElbowAngleDegrees,
200                m_shoulderIndex,
201                m_shoulderSiblingIndex,
202                m_elbowIndex,
203                m_elbowSiblingIndex,
204                m_wristIndex,
205                m_enforceEndPosition,
206                m_enforceEndRotation,
207                m_localFrameName,
208                __ignore,
209            }
210            struct __FieldVisitor;
211            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
212                type Value = __Field;
213                fn expecting(
214                    &self,
215                    __formatter: &mut core::fmt::Formatter,
216                ) -> core::fmt::Result {
217                    core::fmt::Formatter::write_str(__formatter, "field identifier")
218                }
219                /// Intended for use in XML.
220                #[allow(clippy::match_single_binding)]
221                #[allow(clippy::reversed_empty_ranges)]
222                #[allow(clippy::single_match)]
223                fn visit_key<__E>(
224                    self,
225                    __value: &str,
226                ) -> core::result::Result<Self::Value, __E>
227                where
228                    __E: _serde::de::Error,
229                {
230                    match __value {
231                        "elbowAxisLS" => Ok(__Field::m_elbowAxisLS),
232                        "backHandNormalLS" => Ok(__Field::m_backHandNormalLS),
233                        "handOffsetLS" => Ok(__Field::m_handOffsetLS),
234                        "handOrienationOffsetLS" => Ok(__Field::m_handOrienationOffsetLS),
235                        "maxElbowAngleDegrees" => Ok(__Field::m_maxElbowAngleDegrees),
236                        "minElbowAngleDegrees" => Ok(__Field::m_minElbowAngleDegrees),
237                        "shoulderIndex" => Ok(__Field::m_shoulderIndex),
238                        "shoulderSiblingIndex" => Ok(__Field::m_shoulderSiblingIndex),
239                        "elbowIndex" => Ok(__Field::m_elbowIndex),
240                        "elbowSiblingIndex" => Ok(__Field::m_elbowSiblingIndex),
241                        "wristIndex" => Ok(__Field::m_wristIndex),
242                        "enforceEndPosition" => Ok(__Field::m_enforceEndPosition),
243                        "enforceEndRotation" => Ok(__Field::m_enforceEndRotation),
244                        "localFrameName" => Ok(__Field::m_localFrameName),
245                        _ => Ok(__Field::__ignore),
246                    }
247                }
248            }
249            impl<'de> _serde::Deserialize<'de> for __Field {
250                #[inline]
251                fn deserialize<__D>(
252                    __deserializer: __D,
253                ) -> core::result::Result<Self, __D::Error>
254                where
255                    __D: _serde::Deserializer<'de>,
256                {
257                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
258                }
259            }
260            struct __hkbHandIkModifierHandVisitor<'de> {
261                marker: _serde::__private::PhantomData<hkbHandIkModifierHand<'de>>,
262                lifetime: _serde::__private::PhantomData<&'de ()>,
263            }
264            #[allow(clippy::match_single_binding)]
265            #[allow(clippy::reversed_empty_ranges)]
266            #[allow(clippy::single_match)]
267            impl<'de> _serde::de::Visitor<'de> for __hkbHandIkModifierHandVisitor<'de> {
268                type Value = hkbHandIkModifierHand<'de>;
269                fn expecting(
270                    &self,
271                    __formatter: &mut core::fmt::Formatter,
272                ) -> core::fmt::Result {
273                    core::fmt::Formatter::write_str(
274                        __formatter,
275                        "struct hkbHandIkModifierHand",
276                    )
277                }
278                fn visit_struct_for_bytes<__A>(
279                    self,
280                    mut __map: __A,
281                ) -> _serde::__private::Result<Self::Value, __A::Error>
282                where
283                    __A: _serde::de::MapAccess<'de>,
284                {
285                    let __ptr = __A::class_ptr(&mut __map);
286                    let mut m_elbowAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
287                    let mut m_backHandNormalLS: _serde::__private::Option<Vector4> = _serde::__private::None;
288                    let mut m_handOffsetLS: _serde::__private::Option<Vector4> = _serde::__private::None;
289                    let mut m_handOrienationOffsetLS: _serde::__private::Option<
290                        Quaternion,
291                    > = _serde::__private::None;
292                    let mut m_maxElbowAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
293                    let mut m_minElbowAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
294                    let mut m_shoulderIndex: _serde::__private::Option<i16> = _serde::__private::None;
295                    let mut m_shoulderSiblingIndex: _serde::__private::Option<i16> = _serde::__private::None;
296                    let mut m_elbowIndex: _serde::__private::Option<i16> = _serde::__private::None;
297                    let mut m_elbowSiblingIndex: _serde::__private::Option<i16> = _serde::__private::None;
298                    let mut m_wristIndex: _serde::__private::Option<i16> = _serde::__private::None;
299                    let mut m_enforceEndPosition: _serde::__private::Option<bool> = _serde::__private::None;
300                    let mut m_enforceEndRotation: _serde::__private::Option<bool> = _serde::__private::None;
301                    let mut m_localFrameName: _serde::__private::Option<
302                        StringPtr<'de>,
303                    > = _serde::__private::None;
304                    for i in 0..14usize {
305                        match i {
306                            0usize => {
307                                if _serde::__private::Option::is_some(&m_elbowAxisLS) {
308                                    return _serde::__private::Err(
309                                        <__A::Error as _serde::de::Error>::duplicate_field(
310                                            "elbowAxisLS",
311                                        ),
312                                    );
313                                }
314                                m_elbowAxisLS = _serde::__private::Some(
315                                    match __A::next_value::<Vector4>(&mut __map) {
316                                        _serde::__private::Ok(__val) => __val,
317                                        _serde::__private::Err(__err) => {
318                                            return _serde::__private::Err(__err);
319                                        }
320                                    },
321                                );
322                            }
323                            1usize => {
324                                if _serde::__private::Option::is_some(&m_backHandNormalLS) {
325                                    return _serde::__private::Err(
326                                        <__A::Error as _serde::de::Error>::duplicate_field(
327                                            "backHandNormalLS",
328                                        ),
329                                    );
330                                }
331                                m_backHandNormalLS = _serde::__private::Some(
332                                    match __A::next_value::<Vector4>(&mut __map) {
333                                        _serde::__private::Ok(__val) => __val,
334                                        _serde::__private::Err(__err) => {
335                                            return _serde::__private::Err(__err);
336                                        }
337                                    },
338                                );
339                            }
340                            2usize => {
341                                if _serde::__private::Option::is_some(&m_handOffsetLS) {
342                                    return _serde::__private::Err(
343                                        <__A::Error as _serde::de::Error>::duplicate_field(
344                                            "handOffsetLS",
345                                        ),
346                                    );
347                                }
348                                m_handOffsetLS = _serde::__private::Some(
349                                    match __A::next_value::<Vector4>(&mut __map) {
350                                        _serde::__private::Ok(__val) => __val,
351                                        _serde::__private::Err(__err) => {
352                                            return _serde::__private::Err(__err);
353                                        }
354                                    },
355                                );
356                            }
357                            3usize => {
358                                if _serde::__private::Option::is_some(
359                                    &m_handOrienationOffsetLS,
360                                ) {
361                                    return _serde::__private::Err(
362                                        <__A::Error as _serde::de::Error>::duplicate_field(
363                                            "handOrienationOffsetLS",
364                                        ),
365                                    );
366                                }
367                                m_handOrienationOffsetLS = _serde::__private::Some(
368                                    match __A::next_value::<Quaternion>(&mut __map) {
369                                        _serde::__private::Ok(__val) => __val,
370                                        _serde::__private::Err(__err) => {
371                                            return _serde::__private::Err(__err);
372                                        }
373                                    },
374                                );
375                            }
376                            4usize => {
377                                if _serde::__private::Option::is_some(
378                                    &m_maxElbowAngleDegrees,
379                                ) {
380                                    return _serde::__private::Err(
381                                        <__A::Error as _serde::de::Error>::duplicate_field(
382                                            "maxElbowAngleDegrees",
383                                        ),
384                                    );
385                                }
386                                m_maxElbowAngleDegrees = _serde::__private::Some(
387                                    match __A::next_value::<f32>(&mut __map) {
388                                        _serde::__private::Ok(__val) => __val,
389                                        _serde::__private::Err(__err) => {
390                                            return _serde::__private::Err(__err);
391                                        }
392                                    },
393                                );
394                            }
395                            5usize => {
396                                if _serde::__private::Option::is_some(
397                                    &m_minElbowAngleDegrees,
398                                ) {
399                                    return _serde::__private::Err(
400                                        <__A::Error as _serde::de::Error>::duplicate_field(
401                                            "minElbowAngleDegrees",
402                                        ),
403                                    );
404                                }
405                                m_minElbowAngleDegrees = _serde::__private::Some(
406                                    match __A::next_value::<f32>(&mut __map) {
407                                        _serde::__private::Ok(__val) => __val,
408                                        _serde::__private::Err(__err) => {
409                                            return _serde::__private::Err(__err);
410                                        }
411                                    },
412                                );
413                            }
414                            6usize => {
415                                if _serde::__private::Option::is_some(&m_shoulderIndex) {
416                                    return _serde::__private::Err(
417                                        <__A::Error as _serde::de::Error>::duplicate_field(
418                                            "shoulderIndex",
419                                        ),
420                                    );
421                                }
422                                m_shoulderIndex = _serde::__private::Some(
423                                    match __A::next_value::<i16>(&mut __map) {
424                                        _serde::__private::Ok(__val) => __val,
425                                        _serde::__private::Err(__err) => {
426                                            return _serde::__private::Err(__err);
427                                        }
428                                    },
429                                );
430                            }
431                            7usize => {
432                                if _serde::__private::Option::is_some(
433                                    &m_shoulderSiblingIndex,
434                                ) {
435                                    return _serde::__private::Err(
436                                        <__A::Error as _serde::de::Error>::duplicate_field(
437                                            "shoulderSiblingIndex",
438                                        ),
439                                    );
440                                }
441                                m_shoulderSiblingIndex = _serde::__private::Some(
442                                    match __A::next_value::<i16>(&mut __map) {
443                                        _serde::__private::Ok(__val) => __val,
444                                        _serde::__private::Err(__err) => {
445                                            return _serde::__private::Err(__err);
446                                        }
447                                    },
448                                );
449                            }
450                            8usize => {
451                                if _serde::__private::Option::is_some(&m_elbowIndex) {
452                                    return _serde::__private::Err(
453                                        <__A::Error as _serde::de::Error>::duplicate_field(
454                                            "elbowIndex",
455                                        ),
456                                    );
457                                }
458                                m_elbowIndex = _serde::__private::Some(
459                                    match __A::next_value::<i16>(&mut __map) {
460                                        _serde::__private::Ok(__val) => __val,
461                                        _serde::__private::Err(__err) => {
462                                            return _serde::__private::Err(__err);
463                                        }
464                                    },
465                                );
466                            }
467                            9usize => {
468                                if _serde::__private::Option::is_some(
469                                    &m_elbowSiblingIndex,
470                                ) {
471                                    return _serde::__private::Err(
472                                        <__A::Error as _serde::de::Error>::duplicate_field(
473                                            "elbowSiblingIndex",
474                                        ),
475                                    );
476                                }
477                                m_elbowSiblingIndex = _serde::__private::Some(
478                                    match __A::next_value::<i16>(&mut __map) {
479                                        _serde::__private::Ok(__val) => __val,
480                                        _serde::__private::Err(__err) => {
481                                            return _serde::__private::Err(__err);
482                                        }
483                                    },
484                                );
485                            }
486                            10usize => {
487                                if _serde::__private::Option::is_some(&m_wristIndex) {
488                                    return _serde::__private::Err(
489                                        <__A::Error as _serde::de::Error>::duplicate_field(
490                                            "wristIndex",
491                                        ),
492                                    );
493                                }
494                                m_wristIndex = _serde::__private::Some(
495                                    match __A::next_value::<i16>(&mut __map) {
496                                        _serde::__private::Ok(__val) => __val,
497                                        _serde::__private::Err(__err) => {
498                                            return _serde::__private::Err(__err);
499                                        }
500                                    },
501                                );
502                            }
503                            11usize => {
504                                if _serde::__private::Option::is_some(
505                                    &m_enforceEndPosition,
506                                ) {
507                                    return _serde::__private::Err(
508                                        <__A::Error as _serde::de::Error>::duplicate_field(
509                                            "enforceEndPosition",
510                                        ),
511                                    );
512                                }
513                                m_enforceEndPosition = _serde::__private::Some(
514                                    match __A::next_value::<bool>(&mut __map) {
515                                        _serde::__private::Ok(__val) => __val,
516                                        _serde::__private::Err(__err) => {
517                                            return _serde::__private::Err(__err);
518                                        }
519                                    },
520                                );
521                            }
522                            12usize => {
523                                if _serde::__private::Option::is_some(
524                                    &m_enforceEndRotation,
525                                ) {
526                                    return _serde::__private::Err(
527                                        <__A::Error as _serde::de::Error>::duplicate_field(
528                                            "enforceEndRotation",
529                                        ),
530                                    );
531                                }
532                                m_enforceEndRotation = _serde::__private::Some(
533                                    match __A::next_value::<bool>(&mut __map) {
534                                        _serde::__private::Ok(__val) => __val,
535                                        _serde::__private::Err(__err) => {
536                                            return _serde::__private::Err(__err);
537                                        }
538                                    },
539                                );
540                            }
541                            13usize => {
542                                if _serde::__private::Option::is_some(&m_localFrameName) {
543                                    return _serde::__private::Err(
544                                        <__A::Error as _serde::de::Error>::duplicate_field(
545                                            "localFrameName",
546                                        ),
547                                    );
548                                }
549                                __A::pad(&mut __map, 0usize, 4usize)?;
550                                m_localFrameName = _serde::__private::Some(
551                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
552                                        _serde::__private::Ok(__val) => __val,
553                                        _serde::__private::Err(__err) => {
554                                            return _serde::__private::Err(__err);
555                                        }
556                                    },
557                                );
558                            }
559                            _ => {}
560                        }
561                    }
562                    __A::pad(&mut __map, 8usize, 0usize)?;
563                    let m_elbowAxisLS = match m_elbowAxisLS {
564                        _serde::__private::Some(__field) => __field,
565                        _serde::__private::None => {
566                            return _serde::__private::Err(
567                                <__A::Error as _serde::de::Error>::missing_field(
568                                    "elbowAxisLS",
569                                ),
570                            );
571                        }
572                    };
573                    let m_backHandNormalLS = match m_backHandNormalLS {
574                        _serde::__private::Some(__field) => __field,
575                        _serde::__private::None => {
576                            return _serde::__private::Err(
577                                <__A::Error as _serde::de::Error>::missing_field(
578                                    "backHandNormalLS",
579                                ),
580                            );
581                        }
582                    };
583                    let m_handOffsetLS = match m_handOffsetLS {
584                        _serde::__private::Some(__field) => __field,
585                        _serde::__private::None => {
586                            return _serde::__private::Err(
587                                <__A::Error as _serde::de::Error>::missing_field(
588                                    "handOffsetLS",
589                                ),
590                            );
591                        }
592                    };
593                    let m_handOrienationOffsetLS = match m_handOrienationOffsetLS {
594                        _serde::__private::Some(__field) => __field,
595                        _serde::__private::None => {
596                            return _serde::__private::Err(
597                                <__A::Error as _serde::de::Error>::missing_field(
598                                    "handOrienationOffsetLS",
599                                ),
600                            );
601                        }
602                    };
603                    let m_maxElbowAngleDegrees = match m_maxElbowAngleDegrees {
604                        _serde::__private::Some(__field) => __field,
605                        _serde::__private::None => {
606                            return _serde::__private::Err(
607                                <__A::Error as _serde::de::Error>::missing_field(
608                                    "maxElbowAngleDegrees",
609                                ),
610                            );
611                        }
612                    };
613                    let m_minElbowAngleDegrees = match m_minElbowAngleDegrees {
614                        _serde::__private::Some(__field) => __field,
615                        _serde::__private::None => {
616                            return _serde::__private::Err(
617                                <__A::Error as _serde::de::Error>::missing_field(
618                                    "minElbowAngleDegrees",
619                                ),
620                            );
621                        }
622                    };
623                    let m_shoulderIndex = match m_shoulderIndex {
624                        _serde::__private::Some(__field) => __field,
625                        _serde::__private::None => {
626                            return _serde::__private::Err(
627                                <__A::Error as _serde::de::Error>::missing_field(
628                                    "shoulderIndex",
629                                ),
630                            );
631                        }
632                    };
633                    let m_shoulderSiblingIndex = match m_shoulderSiblingIndex {
634                        _serde::__private::Some(__field) => __field,
635                        _serde::__private::None => {
636                            return _serde::__private::Err(
637                                <__A::Error as _serde::de::Error>::missing_field(
638                                    "shoulderSiblingIndex",
639                                ),
640                            );
641                        }
642                    };
643                    let m_elbowIndex = match m_elbowIndex {
644                        _serde::__private::Some(__field) => __field,
645                        _serde::__private::None => {
646                            return _serde::__private::Err(
647                                <__A::Error as _serde::de::Error>::missing_field(
648                                    "elbowIndex",
649                                ),
650                            );
651                        }
652                    };
653                    let m_elbowSiblingIndex = match m_elbowSiblingIndex {
654                        _serde::__private::Some(__field) => __field,
655                        _serde::__private::None => {
656                            return _serde::__private::Err(
657                                <__A::Error as _serde::de::Error>::missing_field(
658                                    "elbowSiblingIndex",
659                                ),
660                            );
661                        }
662                    };
663                    let m_wristIndex = match m_wristIndex {
664                        _serde::__private::Some(__field) => __field,
665                        _serde::__private::None => {
666                            return _serde::__private::Err(
667                                <__A::Error as _serde::de::Error>::missing_field(
668                                    "wristIndex",
669                                ),
670                            );
671                        }
672                    };
673                    let m_enforceEndPosition = match m_enforceEndPosition {
674                        _serde::__private::Some(__field) => __field,
675                        _serde::__private::None => {
676                            return _serde::__private::Err(
677                                <__A::Error as _serde::de::Error>::missing_field(
678                                    "enforceEndPosition",
679                                ),
680                            );
681                        }
682                    };
683                    let m_enforceEndRotation = match m_enforceEndRotation {
684                        _serde::__private::Some(__field) => __field,
685                        _serde::__private::None => {
686                            return _serde::__private::Err(
687                                <__A::Error as _serde::de::Error>::missing_field(
688                                    "enforceEndRotation",
689                                ),
690                            );
691                        }
692                    };
693                    let m_localFrameName = match m_localFrameName {
694                        _serde::__private::Some(__field) => __field,
695                        _serde::__private::None => {
696                            return _serde::__private::Err(
697                                <__A::Error as _serde::de::Error>::missing_field(
698                                    "localFrameName",
699                                ),
700                            );
701                        }
702                    };
703                    _serde::__private::Ok(hkbHandIkModifierHand {
704                        __ptr,
705                        m_elbowAxisLS,
706                        m_backHandNormalLS,
707                        m_handOffsetLS,
708                        m_handOrienationOffsetLS,
709                        m_maxElbowAngleDegrees,
710                        m_minElbowAngleDegrees,
711                        m_shoulderIndex,
712                        m_shoulderSiblingIndex,
713                        m_elbowIndex,
714                        m_elbowSiblingIndex,
715                        m_wristIndex,
716                        m_enforceEndPosition,
717                        m_enforceEndRotation,
718                        m_localFrameName,
719                    })
720                }
721                #[allow(clippy::manual_unwrap_or_default)]
722                fn visit_struct<__A>(
723                    self,
724                    mut __map: __A,
725                ) -> _serde::__private::Result<Self::Value, __A::Error>
726                where
727                    __A: _serde::de::MapAccess<'de>,
728                {
729                    let mut m_elbowAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
730                    let mut m_backHandNormalLS: _serde::__private::Option<Vector4> = _serde::__private::None;
731                    let mut m_handOffsetLS: _serde::__private::Option<Vector4> = _serde::__private::None;
732                    let mut m_handOrienationOffsetLS: _serde::__private::Option<
733                        Quaternion,
734                    > = _serde::__private::None;
735                    let mut m_maxElbowAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
736                    let mut m_minElbowAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
737                    let mut m_shoulderIndex: _serde::__private::Option<i16> = _serde::__private::None;
738                    let mut m_shoulderSiblingIndex: _serde::__private::Option<i16> = _serde::__private::None;
739                    let mut m_elbowIndex: _serde::__private::Option<i16> = _serde::__private::None;
740                    let mut m_elbowSiblingIndex: _serde::__private::Option<i16> = _serde::__private::None;
741                    let mut m_wristIndex: _serde::__private::Option<i16> = _serde::__private::None;
742                    let mut m_enforceEndPosition: _serde::__private::Option<bool> = _serde::__private::None;
743                    let mut m_enforceEndRotation: _serde::__private::Option<bool> = _serde::__private::None;
744                    let mut m_localFrameName: _serde::__private::Option<
745                        StringPtr<'de>,
746                    > = _serde::__private::None;
747                    while let _serde::__private::Some(__key) = {
748                        __A::next_key::<__Field>(&mut __map)?
749                    } {
750                        match __key {
751                            __Field::m_elbowAxisLS => {
752                                #[cfg(
753                                    any(feature = "strict", feature = "ignore_duplicates")
754                                )]
755                                if _serde::__private::Option::is_some(&m_elbowAxisLS) {
756                                    #[cfg(feature = "ignore_duplicates")]
757                                    {
758                                        __A::skip_value(&mut __map)?;
759                                        continue;
760                                    }
761                                    #[cfg(feature = "strict")]
762                                    return _serde::__private::Err(
763                                        <__A::Error as _serde::de::Error>::duplicate_field(
764                                            "elbowAxisLS",
765                                        ),
766                                    );
767                                }
768                                m_elbowAxisLS = _serde::__private::Some(
769                                    match __A::next_value::<Vector4>(&mut __map) {
770                                        _serde::__private::Ok(__val) => __val,
771                                        _serde::__private::Err(__err) => {
772                                            return _serde::__private::Err(__err);
773                                        }
774                                    },
775                                );
776                            }
777                            __Field::m_backHandNormalLS => {
778                                #[cfg(
779                                    any(feature = "strict", feature = "ignore_duplicates")
780                                )]
781                                if _serde::__private::Option::is_some(&m_backHandNormalLS) {
782                                    #[cfg(feature = "ignore_duplicates")]
783                                    {
784                                        __A::skip_value(&mut __map)?;
785                                        continue;
786                                    }
787                                    #[cfg(feature = "strict")]
788                                    return _serde::__private::Err(
789                                        <__A::Error as _serde::de::Error>::duplicate_field(
790                                            "backHandNormalLS",
791                                        ),
792                                    );
793                                }
794                                m_backHandNormalLS = _serde::__private::Some(
795                                    match __A::next_value::<Vector4>(&mut __map) {
796                                        _serde::__private::Ok(__val) => __val,
797                                        _serde::__private::Err(__err) => {
798                                            return _serde::__private::Err(__err);
799                                        }
800                                    },
801                                );
802                            }
803                            __Field::m_handOffsetLS => {
804                                #[cfg(
805                                    any(feature = "strict", feature = "ignore_duplicates")
806                                )]
807                                if _serde::__private::Option::is_some(&m_handOffsetLS) {
808                                    #[cfg(feature = "ignore_duplicates")]
809                                    {
810                                        __A::skip_value(&mut __map)?;
811                                        continue;
812                                    }
813                                    #[cfg(feature = "strict")]
814                                    return _serde::__private::Err(
815                                        <__A::Error as _serde::de::Error>::duplicate_field(
816                                            "handOffsetLS",
817                                        ),
818                                    );
819                                }
820                                m_handOffsetLS = _serde::__private::Some(
821                                    match __A::next_value::<Vector4>(&mut __map) {
822                                        _serde::__private::Ok(__val) => __val,
823                                        _serde::__private::Err(__err) => {
824                                            return _serde::__private::Err(__err);
825                                        }
826                                    },
827                                );
828                            }
829                            __Field::m_handOrienationOffsetLS => {
830                                #[cfg(
831                                    any(feature = "strict", feature = "ignore_duplicates")
832                                )]
833                                if _serde::__private::Option::is_some(
834                                    &m_handOrienationOffsetLS,
835                                ) {
836                                    #[cfg(feature = "ignore_duplicates")]
837                                    {
838                                        __A::skip_value(&mut __map)?;
839                                        continue;
840                                    }
841                                    #[cfg(feature = "strict")]
842                                    return _serde::__private::Err(
843                                        <__A::Error as _serde::de::Error>::duplicate_field(
844                                            "handOrienationOffsetLS",
845                                        ),
846                                    );
847                                }
848                                m_handOrienationOffsetLS = _serde::__private::Some(
849                                    match __A::next_value::<Quaternion>(&mut __map) {
850                                        _serde::__private::Ok(__val) => __val,
851                                        _serde::__private::Err(__err) => {
852                                            return _serde::__private::Err(__err);
853                                        }
854                                    },
855                                );
856                            }
857                            __Field::m_maxElbowAngleDegrees => {
858                                #[cfg(
859                                    any(feature = "strict", feature = "ignore_duplicates")
860                                )]
861                                if _serde::__private::Option::is_some(
862                                    &m_maxElbowAngleDegrees,
863                                ) {
864                                    #[cfg(feature = "ignore_duplicates")]
865                                    {
866                                        __A::skip_value(&mut __map)?;
867                                        continue;
868                                    }
869                                    #[cfg(feature = "strict")]
870                                    return _serde::__private::Err(
871                                        <__A::Error as _serde::de::Error>::duplicate_field(
872                                            "maxElbowAngleDegrees",
873                                        ),
874                                    );
875                                }
876                                m_maxElbowAngleDegrees = _serde::__private::Some(
877                                    match __A::next_value::<f32>(&mut __map) {
878                                        _serde::__private::Ok(__val) => __val,
879                                        _serde::__private::Err(__err) => {
880                                            return _serde::__private::Err(__err);
881                                        }
882                                    },
883                                );
884                            }
885                            __Field::m_minElbowAngleDegrees => {
886                                #[cfg(
887                                    any(feature = "strict", feature = "ignore_duplicates")
888                                )]
889                                if _serde::__private::Option::is_some(
890                                    &m_minElbowAngleDegrees,
891                                ) {
892                                    #[cfg(feature = "ignore_duplicates")]
893                                    {
894                                        __A::skip_value(&mut __map)?;
895                                        continue;
896                                    }
897                                    #[cfg(feature = "strict")]
898                                    return _serde::__private::Err(
899                                        <__A::Error as _serde::de::Error>::duplicate_field(
900                                            "minElbowAngleDegrees",
901                                        ),
902                                    );
903                                }
904                                m_minElbowAngleDegrees = _serde::__private::Some(
905                                    match __A::next_value::<f32>(&mut __map) {
906                                        _serde::__private::Ok(__val) => __val,
907                                        _serde::__private::Err(__err) => {
908                                            return _serde::__private::Err(__err);
909                                        }
910                                    },
911                                );
912                            }
913                            __Field::m_shoulderIndex => {
914                                #[cfg(
915                                    any(feature = "strict", feature = "ignore_duplicates")
916                                )]
917                                if _serde::__private::Option::is_some(&m_shoulderIndex) {
918                                    #[cfg(feature = "ignore_duplicates")]
919                                    {
920                                        __A::skip_value(&mut __map)?;
921                                        continue;
922                                    }
923                                    #[cfg(feature = "strict")]
924                                    return _serde::__private::Err(
925                                        <__A::Error as _serde::de::Error>::duplicate_field(
926                                            "shoulderIndex",
927                                        ),
928                                    );
929                                }
930                                m_shoulderIndex = _serde::__private::Some(
931                                    match __A::next_value::<i16>(&mut __map) {
932                                        _serde::__private::Ok(__val) => __val,
933                                        _serde::__private::Err(__err) => {
934                                            return _serde::__private::Err(__err);
935                                        }
936                                    },
937                                );
938                            }
939                            __Field::m_shoulderSiblingIndex => {
940                                #[cfg(
941                                    any(feature = "strict", feature = "ignore_duplicates")
942                                )]
943                                if _serde::__private::Option::is_some(
944                                    &m_shoulderSiblingIndex,
945                                ) {
946                                    #[cfg(feature = "ignore_duplicates")]
947                                    {
948                                        __A::skip_value(&mut __map)?;
949                                        continue;
950                                    }
951                                    #[cfg(feature = "strict")]
952                                    return _serde::__private::Err(
953                                        <__A::Error as _serde::de::Error>::duplicate_field(
954                                            "shoulderSiblingIndex",
955                                        ),
956                                    );
957                                }
958                                m_shoulderSiblingIndex = _serde::__private::Some(
959                                    match __A::next_value::<i16>(&mut __map) {
960                                        _serde::__private::Ok(__val) => __val,
961                                        _serde::__private::Err(__err) => {
962                                            return _serde::__private::Err(__err);
963                                        }
964                                    },
965                                );
966                            }
967                            __Field::m_elbowIndex => {
968                                #[cfg(
969                                    any(feature = "strict", feature = "ignore_duplicates")
970                                )]
971                                if _serde::__private::Option::is_some(&m_elbowIndex) {
972                                    #[cfg(feature = "ignore_duplicates")]
973                                    {
974                                        __A::skip_value(&mut __map)?;
975                                        continue;
976                                    }
977                                    #[cfg(feature = "strict")]
978                                    return _serde::__private::Err(
979                                        <__A::Error as _serde::de::Error>::duplicate_field(
980                                            "elbowIndex",
981                                        ),
982                                    );
983                                }
984                                m_elbowIndex = _serde::__private::Some(
985                                    match __A::next_value::<i16>(&mut __map) {
986                                        _serde::__private::Ok(__val) => __val,
987                                        _serde::__private::Err(__err) => {
988                                            return _serde::__private::Err(__err);
989                                        }
990                                    },
991                                );
992                            }
993                            __Field::m_elbowSiblingIndex => {
994                                #[cfg(
995                                    any(feature = "strict", feature = "ignore_duplicates")
996                                )]
997                                if _serde::__private::Option::is_some(
998                                    &m_elbowSiblingIndex,
999                                ) {
1000                                    #[cfg(feature = "ignore_duplicates")]
1001                                    {
1002                                        __A::skip_value(&mut __map)?;
1003                                        continue;
1004                                    }
1005                                    #[cfg(feature = "strict")]
1006                                    return _serde::__private::Err(
1007                                        <__A::Error as _serde::de::Error>::duplicate_field(
1008                                            "elbowSiblingIndex",
1009                                        ),
1010                                    );
1011                                }
1012                                m_elbowSiblingIndex = _serde::__private::Some(
1013                                    match __A::next_value::<i16>(&mut __map) {
1014                                        _serde::__private::Ok(__val) => __val,
1015                                        _serde::__private::Err(__err) => {
1016                                            return _serde::__private::Err(__err);
1017                                        }
1018                                    },
1019                                );
1020                            }
1021                            __Field::m_wristIndex => {
1022                                #[cfg(
1023                                    any(feature = "strict", feature = "ignore_duplicates")
1024                                )]
1025                                if _serde::__private::Option::is_some(&m_wristIndex) {
1026                                    #[cfg(feature = "ignore_duplicates")]
1027                                    {
1028                                        __A::skip_value(&mut __map)?;
1029                                        continue;
1030                                    }
1031                                    #[cfg(feature = "strict")]
1032                                    return _serde::__private::Err(
1033                                        <__A::Error as _serde::de::Error>::duplicate_field(
1034                                            "wristIndex",
1035                                        ),
1036                                    );
1037                                }
1038                                m_wristIndex = _serde::__private::Some(
1039                                    match __A::next_value::<i16>(&mut __map) {
1040                                        _serde::__private::Ok(__val) => __val,
1041                                        _serde::__private::Err(__err) => {
1042                                            return _serde::__private::Err(__err);
1043                                        }
1044                                    },
1045                                );
1046                            }
1047                            __Field::m_enforceEndPosition => {
1048                                #[cfg(
1049                                    any(feature = "strict", feature = "ignore_duplicates")
1050                                )]
1051                                if _serde::__private::Option::is_some(
1052                                    &m_enforceEndPosition,
1053                                ) {
1054                                    #[cfg(feature = "ignore_duplicates")]
1055                                    {
1056                                        __A::skip_value(&mut __map)?;
1057                                        continue;
1058                                    }
1059                                    #[cfg(feature = "strict")]
1060                                    return _serde::__private::Err(
1061                                        <__A::Error as _serde::de::Error>::duplicate_field(
1062                                            "enforceEndPosition",
1063                                        ),
1064                                    );
1065                                }
1066                                m_enforceEndPosition = _serde::__private::Some(
1067                                    match __A::next_value::<bool>(&mut __map) {
1068                                        _serde::__private::Ok(__val) => __val,
1069                                        _serde::__private::Err(__err) => {
1070                                            return _serde::__private::Err(__err);
1071                                        }
1072                                    },
1073                                );
1074                            }
1075                            __Field::m_enforceEndRotation => {
1076                                #[cfg(
1077                                    any(feature = "strict", feature = "ignore_duplicates")
1078                                )]
1079                                if _serde::__private::Option::is_some(
1080                                    &m_enforceEndRotation,
1081                                ) {
1082                                    #[cfg(feature = "ignore_duplicates")]
1083                                    {
1084                                        __A::skip_value(&mut __map)?;
1085                                        continue;
1086                                    }
1087                                    #[cfg(feature = "strict")]
1088                                    return _serde::__private::Err(
1089                                        <__A::Error as _serde::de::Error>::duplicate_field(
1090                                            "enforceEndRotation",
1091                                        ),
1092                                    );
1093                                }
1094                                m_enforceEndRotation = _serde::__private::Some(
1095                                    match __A::next_value::<bool>(&mut __map) {
1096                                        _serde::__private::Ok(__val) => __val,
1097                                        _serde::__private::Err(__err) => {
1098                                            return _serde::__private::Err(__err);
1099                                        }
1100                                    },
1101                                );
1102                            }
1103                            __Field::m_localFrameName => {
1104                                #[cfg(
1105                                    any(feature = "strict", feature = "ignore_duplicates")
1106                                )]
1107                                if _serde::__private::Option::is_some(&m_localFrameName) {
1108                                    #[cfg(feature = "ignore_duplicates")]
1109                                    {
1110                                        __A::skip_value(&mut __map)?;
1111                                        continue;
1112                                    }
1113                                    #[cfg(feature = "strict")]
1114                                    return _serde::__private::Err(
1115                                        <__A::Error as _serde::de::Error>::duplicate_field(
1116                                            "localFrameName",
1117                                        ),
1118                                    );
1119                                }
1120                                m_localFrameName = _serde::__private::Some(
1121                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
1122                                        _serde::__private::Ok(__val) => __val,
1123                                        _serde::__private::Err(__err) => {
1124                                            return _serde::__private::Err(__err);
1125                                        }
1126                                    },
1127                                );
1128                            }
1129                            _ => __A::skip_value(&mut __map)?,
1130                        }
1131                    }
1132                    let m_elbowAxisLS = match m_elbowAxisLS {
1133                        _serde::__private::Some(__field) => __field,
1134                        _serde::__private::None => {
1135                            #[cfg(feature = "strict")]
1136                            return _serde::__private::Err(
1137                                <__A::Error as _serde::de::Error>::missing_field(
1138                                    "elbowAxisLS",
1139                                ),
1140                            );
1141                            #[cfg(not(feature = "strict"))] Default::default()
1142                        }
1143                    };
1144                    let m_backHandNormalLS = match m_backHandNormalLS {
1145                        _serde::__private::Some(__field) => __field,
1146                        _serde::__private::None => {
1147                            #[cfg(feature = "strict")]
1148                            return _serde::__private::Err(
1149                                <__A::Error as _serde::de::Error>::missing_field(
1150                                    "backHandNormalLS",
1151                                ),
1152                            );
1153                            #[cfg(not(feature = "strict"))] Default::default()
1154                        }
1155                    };
1156                    let m_handOffsetLS = match m_handOffsetLS {
1157                        _serde::__private::Some(__field) => __field,
1158                        _serde::__private::None => {
1159                            #[cfg(feature = "strict")]
1160                            return _serde::__private::Err(
1161                                <__A::Error as _serde::de::Error>::missing_field(
1162                                    "handOffsetLS",
1163                                ),
1164                            );
1165                            #[cfg(not(feature = "strict"))] Default::default()
1166                        }
1167                    };
1168                    let m_handOrienationOffsetLS = match m_handOrienationOffsetLS {
1169                        _serde::__private::Some(__field) => __field,
1170                        _serde::__private::None => {
1171                            #[cfg(feature = "strict")]
1172                            return _serde::__private::Err(
1173                                <__A::Error as _serde::de::Error>::missing_field(
1174                                    "handOrienationOffsetLS",
1175                                ),
1176                            );
1177                            #[cfg(not(feature = "strict"))] Default::default()
1178                        }
1179                    };
1180                    let m_maxElbowAngleDegrees = match m_maxElbowAngleDegrees {
1181                        _serde::__private::Some(__field) => __field,
1182                        _serde::__private::None => {
1183                            #[cfg(feature = "strict")]
1184                            return _serde::__private::Err(
1185                                <__A::Error as _serde::de::Error>::missing_field(
1186                                    "maxElbowAngleDegrees",
1187                                ),
1188                            );
1189                            #[cfg(not(feature = "strict"))] Default::default()
1190                        }
1191                    };
1192                    let m_minElbowAngleDegrees = match m_minElbowAngleDegrees {
1193                        _serde::__private::Some(__field) => __field,
1194                        _serde::__private::None => {
1195                            #[cfg(feature = "strict")]
1196                            return _serde::__private::Err(
1197                                <__A::Error as _serde::de::Error>::missing_field(
1198                                    "minElbowAngleDegrees",
1199                                ),
1200                            );
1201                            #[cfg(not(feature = "strict"))] Default::default()
1202                        }
1203                    };
1204                    let m_shoulderIndex = match m_shoulderIndex {
1205                        _serde::__private::Some(__field) => __field,
1206                        _serde::__private::None => {
1207                            #[cfg(feature = "strict")]
1208                            return _serde::__private::Err(
1209                                <__A::Error as _serde::de::Error>::missing_field(
1210                                    "shoulderIndex",
1211                                ),
1212                            );
1213                            #[cfg(not(feature = "strict"))] Default::default()
1214                        }
1215                    };
1216                    let m_shoulderSiblingIndex = match m_shoulderSiblingIndex {
1217                        _serde::__private::Some(__field) => __field,
1218                        _serde::__private::None => {
1219                            #[cfg(feature = "strict")]
1220                            return _serde::__private::Err(
1221                                <__A::Error as _serde::de::Error>::missing_field(
1222                                    "shoulderSiblingIndex",
1223                                ),
1224                            );
1225                            #[cfg(not(feature = "strict"))] Default::default()
1226                        }
1227                    };
1228                    let m_elbowIndex = match m_elbowIndex {
1229                        _serde::__private::Some(__field) => __field,
1230                        _serde::__private::None => {
1231                            #[cfg(feature = "strict")]
1232                            return _serde::__private::Err(
1233                                <__A::Error as _serde::de::Error>::missing_field(
1234                                    "elbowIndex",
1235                                ),
1236                            );
1237                            #[cfg(not(feature = "strict"))] Default::default()
1238                        }
1239                    };
1240                    let m_elbowSiblingIndex = match m_elbowSiblingIndex {
1241                        _serde::__private::Some(__field) => __field,
1242                        _serde::__private::None => {
1243                            #[cfg(feature = "strict")]
1244                            return _serde::__private::Err(
1245                                <__A::Error as _serde::de::Error>::missing_field(
1246                                    "elbowSiblingIndex",
1247                                ),
1248                            );
1249                            #[cfg(not(feature = "strict"))] Default::default()
1250                        }
1251                    };
1252                    let m_wristIndex = match m_wristIndex {
1253                        _serde::__private::Some(__field) => __field,
1254                        _serde::__private::None => {
1255                            #[cfg(feature = "strict")]
1256                            return _serde::__private::Err(
1257                                <__A::Error as _serde::de::Error>::missing_field(
1258                                    "wristIndex",
1259                                ),
1260                            );
1261                            #[cfg(not(feature = "strict"))] Default::default()
1262                        }
1263                    };
1264                    let m_enforceEndPosition = match m_enforceEndPosition {
1265                        _serde::__private::Some(__field) => __field,
1266                        _serde::__private::None => {
1267                            #[cfg(feature = "strict")]
1268                            return _serde::__private::Err(
1269                                <__A::Error as _serde::de::Error>::missing_field(
1270                                    "enforceEndPosition",
1271                                ),
1272                            );
1273                            #[cfg(not(feature = "strict"))] Default::default()
1274                        }
1275                    };
1276                    let m_enforceEndRotation = match m_enforceEndRotation {
1277                        _serde::__private::Some(__field) => __field,
1278                        _serde::__private::None => {
1279                            #[cfg(feature = "strict")]
1280                            return _serde::__private::Err(
1281                                <__A::Error as _serde::de::Error>::missing_field(
1282                                    "enforceEndRotation",
1283                                ),
1284                            );
1285                            #[cfg(not(feature = "strict"))] Default::default()
1286                        }
1287                    };
1288                    let m_localFrameName = match m_localFrameName {
1289                        _serde::__private::Some(__field) => __field,
1290                        _serde::__private::None => {
1291                            #[cfg(feature = "strict")]
1292                            return _serde::__private::Err(
1293                                <__A::Error as _serde::de::Error>::missing_field(
1294                                    "localFrameName",
1295                                ),
1296                            );
1297                            #[cfg(not(feature = "strict"))] Default::default()
1298                        }
1299                    };
1300                    let __ptr = __A::class_ptr(&mut __map);
1301                    _serde::__private::Ok(hkbHandIkModifierHand {
1302                        __ptr,
1303                        m_elbowAxisLS,
1304                        m_backHandNormalLS,
1305                        m_handOffsetLS,
1306                        m_handOrienationOffsetLS,
1307                        m_maxElbowAngleDegrees,
1308                        m_minElbowAngleDegrees,
1309                        m_shoulderIndex,
1310                        m_shoulderSiblingIndex,
1311                        m_elbowIndex,
1312                        m_elbowSiblingIndex,
1313                        m_wristIndex,
1314                        m_enforceEndPosition,
1315                        m_enforceEndRotation,
1316                        m_localFrameName,
1317                    })
1318                }
1319            }
1320            const FIELDS: &[&str] = &[
1321                "elbowAxisLS",
1322                "backHandNormalLS",
1323                "handOffsetLS",
1324                "handOrienationOffsetLS",
1325                "maxElbowAngleDegrees",
1326                "minElbowAngleDegrees",
1327                "shoulderIndex",
1328                "shoulderSiblingIndex",
1329                "elbowIndex",
1330                "elbowSiblingIndex",
1331                "wristIndex",
1332                "enforceEndPosition",
1333                "enforceEndRotation",
1334                "localFrameName",
1335            ];
1336            _serde::Deserializer::deserialize_struct(
1337                deserializer,
1338                "hkbHandIkModifierHand",
1339                FIELDS,
1340                __hkbHandIkModifierHandVisitor {
1341                    marker: _serde::__private::PhantomData::<hkbHandIkModifierHand>,
1342                    lifetime: _serde::__private::PhantomData,
1343                },
1344            )
1345        }
1346    }
1347};