havok_classes/generated/
hkbLookAtModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbLookAtModifier`
5/// - version: `3`
6/// - signature: `0x3d28e066`
7/// - size: `208`(x86)/`240`(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 hkbLookAtModifier<'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: `targetWS`(ctype: `hkVector4`)
33    /// - offset: ` 48`(x86)/` 80`(x86_64)
34    /// - type_size: ` 16`(x86)/` 16`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "targetWS"))]
36    #[cfg_attr(feature = "serde", serde(rename = "targetWS"))]
37    pub m_targetWS: Vector4,
38    /// # C++ Info
39    /// - name: `headForwardLS`(ctype: `hkVector4`)
40    /// - offset: ` 64`(x86)/` 96`(x86_64)
41    /// - type_size: ` 16`(x86)/` 16`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "headForwardLS"))]
43    #[cfg_attr(feature = "serde", serde(rename = "headForwardLS"))]
44    pub m_headForwardLS: Vector4,
45    /// # C++ Info
46    /// - name: `neckForwardLS`(ctype: `hkVector4`)
47    /// - offset: ` 80`(x86)/`112`(x86_64)
48    /// - type_size: ` 16`(x86)/` 16`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "neckForwardLS"))]
50    #[cfg_attr(feature = "serde", serde(rename = "neckForwardLS"))]
51    pub m_neckForwardLS: Vector4,
52    /// # C++ Info
53    /// - name: `neckRightLS`(ctype: `hkVector4`)
54    /// - offset: ` 96`(x86)/`128`(x86_64)
55    /// - type_size: ` 16`(x86)/` 16`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "neckRightLS"))]
57    #[cfg_attr(feature = "serde", serde(rename = "neckRightLS"))]
58    pub m_neckRightLS: Vector4,
59    /// # C++ Info
60    /// - name: `eyePositionHS`(ctype: `hkVector4`)
61    /// - offset: `112`(x86)/`144`(x86_64)
62    /// - type_size: ` 16`(x86)/` 16`(x86_64)
63    #[cfg_attr(feature = "json_schema", schemars(rename = "eyePositionHS"))]
64    #[cfg_attr(feature = "serde", serde(rename = "eyePositionHS"))]
65    pub m_eyePositionHS: Vector4,
66    /// # C++ Info
67    /// - name: `newTargetGain`(ctype: `hkReal`)
68    /// - offset: `128`(x86)/`160`(x86_64)
69    /// - type_size: `  4`(x86)/`  4`(x86_64)
70    #[cfg_attr(feature = "json_schema", schemars(rename = "newTargetGain"))]
71    #[cfg_attr(feature = "serde", serde(rename = "newTargetGain"))]
72    pub m_newTargetGain: f32,
73    /// # C++ Info
74    /// - name: `onGain`(ctype: `hkReal`)
75    /// - offset: `132`(x86)/`164`(x86_64)
76    /// - type_size: `  4`(x86)/`  4`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "onGain"))]
78    #[cfg_attr(feature = "serde", serde(rename = "onGain"))]
79    pub m_onGain: f32,
80    /// # C++ Info
81    /// - name: `offGain`(ctype: `hkReal`)
82    /// - offset: `136`(x86)/`168`(x86_64)
83    /// - type_size: `  4`(x86)/`  4`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "offGain"))]
85    #[cfg_attr(feature = "serde", serde(rename = "offGain"))]
86    pub m_offGain: f32,
87    /// # C++ Info
88    /// - name: `limitAngleDegrees`(ctype: `hkReal`)
89    /// - offset: `140`(x86)/`172`(x86_64)
90    /// - type_size: `  4`(x86)/`  4`(x86_64)
91    #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleDegrees"))]
92    #[cfg_attr(feature = "serde", serde(rename = "limitAngleDegrees"))]
93    pub m_limitAngleDegrees: f32,
94    /// # C++ Info
95    /// - name: `limitAngleLeft`(ctype: `hkReal`)
96    /// - offset: `144`(x86)/`176`(x86_64)
97    /// - type_size: `  4`(x86)/`  4`(x86_64)
98    #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleLeft"))]
99    #[cfg_attr(feature = "serde", serde(rename = "limitAngleLeft"))]
100    pub m_limitAngleLeft: f32,
101    /// # C++ Info
102    /// - name: `limitAngleRight`(ctype: `hkReal`)
103    /// - offset: `148`(x86)/`180`(x86_64)
104    /// - type_size: `  4`(x86)/`  4`(x86_64)
105    #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleRight"))]
106    #[cfg_attr(feature = "serde", serde(rename = "limitAngleRight"))]
107    pub m_limitAngleRight: f32,
108    /// # C++ Info
109    /// - name: `limitAngleUp`(ctype: `hkReal`)
110    /// - offset: `152`(x86)/`184`(x86_64)
111    /// - type_size: `  4`(x86)/`  4`(x86_64)
112    #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleUp"))]
113    #[cfg_attr(feature = "serde", serde(rename = "limitAngleUp"))]
114    pub m_limitAngleUp: f32,
115    /// # C++ Info
116    /// - name: `limitAngleDown`(ctype: `hkReal`)
117    /// - offset: `156`(x86)/`188`(x86_64)
118    /// - type_size: `  4`(x86)/`  4`(x86_64)
119    #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleDown"))]
120    #[cfg_attr(feature = "serde", serde(rename = "limitAngleDown"))]
121    pub m_limitAngleDown: f32,
122    /// # C++ Info
123    /// - name: `headIndex`(ctype: `hkInt16`)
124    /// - offset: `160`(x86)/`192`(x86_64)
125    /// - type_size: `  2`(x86)/`  2`(x86_64)
126    #[cfg_attr(feature = "json_schema", schemars(rename = "headIndex"))]
127    #[cfg_attr(feature = "serde", serde(rename = "headIndex"))]
128    pub m_headIndex: i16,
129    /// # C++ Info
130    /// - name: `neckIndex`(ctype: `hkInt16`)
131    /// - offset: `162`(x86)/`194`(x86_64)
132    /// - type_size: `  2`(x86)/`  2`(x86_64)
133    #[cfg_attr(feature = "json_schema", schemars(rename = "neckIndex"))]
134    #[cfg_attr(feature = "serde", serde(rename = "neckIndex"))]
135    pub m_neckIndex: i16,
136    /// # C++ Info
137    /// - name: `isOn`(ctype: `hkBool`)
138    /// - offset: `164`(x86)/`196`(x86_64)
139    /// - type_size: `  1`(x86)/`  1`(x86_64)
140    #[cfg_attr(feature = "json_schema", schemars(rename = "isOn"))]
141    #[cfg_attr(feature = "serde", serde(rename = "isOn"))]
142    pub m_isOn: bool,
143    /// # C++ Info
144    /// - name: `individualLimitsOn`(ctype: `hkBool`)
145    /// - offset: `165`(x86)/`197`(x86_64)
146    /// - type_size: `  1`(x86)/`  1`(x86_64)
147    #[cfg_attr(feature = "json_schema", schemars(rename = "individualLimitsOn"))]
148    #[cfg_attr(feature = "serde", serde(rename = "individualLimitsOn"))]
149    pub m_individualLimitsOn: bool,
150    /// # C++ Info
151    /// - name: `isTargetInsideLimitCone`(ctype: `hkBool`)
152    /// - offset: `166`(x86)/`198`(x86_64)
153    /// - type_size: `  1`(x86)/`  1`(x86_64)
154    #[cfg_attr(feature = "json_schema", schemars(rename = "isTargetInsideLimitCone"))]
155    #[cfg_attr(feature = "serde", serde(rename = "isTargetInsideLimitCone"))]
156    pub m_isTargetInsideLimitCone: bool,
157    /// # C++ Info
158    /// - name: `lookAtLastTargetWS`(ctype: `hkVector4`)
159    /// - offset: `176`(x86)/`208`(x86_64)
160    /// - type_size: ` 16`(x86)/` 16`(x86_64)
161    /// - flags: `SERIALIZE_IGNORED`
162    #[cfg_attr(feature = "json_schema", schemars(rename = "lookAtLastTargetWS"))]
163    #[cfg_attr(feature = "serde", serde(rename = "lookAtLastTargetWS"))]
164    pub m_lookAtLastTargetWS: Vector4,
165    /// # C++ Info
166    /// - name: `lookAtWeight`(ctype: `hkReal`)
167    /// - offset: `192`(x86)/`224`(x86_64)
168    /// - type_size: `  4`(x86)/`  4`(x86_64)
169    /// - flags: `SERIALIZE_IGNORED`
170    #[cfg_attr(feature = "json_schema", schemars(rename = "lookAtWeight"))]
171    #[cfg_attr(feature = "serde", serde(rename = "lookAtWeight"))]
172    pub m_lookAtWeight: f32,
173}
174const _: () = {
175    use havok_serde as _serde;
176    impl<'a> _serde::HavokClass for hkbLookAtModifier<'a> {
177        #[inline]
178        fn name(&self) -> &'static str {
179            "hkbLookAtModifier"
180        }
181        #[inline]
182        fn signature(&self) -> _serde::__private::Signature {
183            _serde::__private::Signature::new(0x3d28e066)
184        }
185        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
186        fn deps_indexes(&self) -> Vec<usize> {
187            let mut v = Vec::new();
188            v.push(self.parent.parent.parent.m_variableBindingSet.get());
189            v
190        }
191    }
192    impl<'a> _serde::Serialize for hkbLookAtModifier<'a> {
193        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
194        where
195            S: _serde::ser::Serializer,
196        {
197            let class_meta = self
198                .__ptr
199                .map(|name| (name, _serde::__private::Signature::new(0x3d28e066)));
200            let mut serializer = __serializer
201                .serialize_struct("hkbLookAtModifier", class_meta, (208u64, 240u64))?;
202            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
203            serializer
204                .skip_field(
205                    "memSizeAndFlags",
206                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
207                )?;
208            serializer
209                .skip_field(
210                    "referenceCount",
211                    &self.parent.parent.parent.parent.m_referenceCount,
212                )?;
213            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
214            serializer
215                .serialize_field(
216                    "variableBindingSet",
217                    &self.parent.parent.parent.m_variableBindingSet,
218                )?;
219            serializer
220                .skip_array_field(
221                    "cachedBindables",
222                    &self.parent.parent.parent.m_cachedBindables,
223                    TypeSize::NonPtr,
224                )?;
225            serializer
226                .skip_field(
227                    "areBindablesCached",
228                    &self.parent.parent.parent.m_areBindablesCached,
229                )?;
230            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
231            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
232            serializer.serialize_field("name", &self.parent.parent.m_name)?;
233            serializer.skip_field("id", &self.parent.parent.m_id)?;
234            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
235            serializer
236                .skip_fixed_array_field(
237                    "padNode",
238                    self.parent.parent.m_padNode.as_slice(),
239                    TypeSize::NonPtr,
240                )?;
241            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
242            serializer.serialize_field("enable", &self.parent.m_enable)?;
243            serializer
244                .skip_fixed_array_field(
245                    "padModifier",
246                    self.parent.m_padModifier.as_slice(),
247                    TypeSize::NonPtr,
248                )?;
249            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
250            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
251            serializer.serialize_field("targetWS", &self.m_targetWS)?;
252            serializer.serialize_field("headForwardLS", &self.m_headForwardLS)?;
253            serializer.serialize_field("neckForwardLS", &self.m_neckForwardLS)?;
254            serializer.serialize_field("neckRightLS", &self.m_neckRightLS)?;
255            serializer.serialize_field("eyePositionHS", &self.m_eyePositionHS)?;
256            serializer.serialize_field("newTargetGain", &self.m_newTargetGain)?;
257            serializer.serialize_field("onGain", &self.m_onGain)?;
258            serializer.serialize_field("offGain", &self.m_offGain)?;
259            serializer.serialize_field("limitAngleDegrees", &self.m_limitAngleDegrees)?;
260            serializer.serialize_field("limitAngleLeft", &self.m_limitAngleLeft)?;
261            serializer.serialize_field("limitAngleRight", &self.m_limitAngleRight)?;
262            serializer.serialize_field("limitAngleUp", &self.m_limitAngleUp)?;
263            serializer.serialize_field("limitAngleDown", &self.m_limitAngleDown)?;
264            serializer.serialize_field("headIndex", &self.m_headIndex)?;
265            serializer.serialize_field("neckIndex", &self.m_neckIndex)?;
266            serializer.serialize_field("isOn", &self.m_isOn)?;
267            serializer
268                .serialize_field("individualLimitsOn", &self.m_individualLimitsOn)?;
269            serializer
270                .serialize_field(
271                    "isTargetInsideLimitCone",
272                    &self.m_isTargetInsideLimitCone,
273                )?;
274            serializer.pad_field([0u8; 9usize].as_slice(), [0u8; 9usize].as_slice())?;
275            serializer.skip_field("lookAtLastTargetWS", &self.m_lookAtLastTargetWS)?;
276            serializer.skip_field("lookAtWeight", &self.m_lookAtWeight)?;
277            serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 12usize].as_slice())?;
278            serializer.end()
279        }
280    }
281};
282#[doc(hidden)]
283#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
284const _: () = {
285    use havok_serde as _serde;
286    #[automatically_derived]
287    impl<'de> _serde::Deserialize<'de> for hkbLookAtModifier<'de> {
288        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
289        where
290            __D: _serde::Deserializer<'de>,
291        {
292            #[allow(non_camel_case_types)]
293            enum __Field {
294                m_variableBindingSet,
295                m_userData,
296                m_name,
297                m_enable,
298                m_targetWS,
299                m_headForwardLS,
300                m_neckForwardLS,
301                m_neckRightLS,
302                m_eyePositionHS,
303                m_newTargetGain,
304                m_onGain,
305                m_offGain,
306                m_limitAngleDegrees,
307                m_limitAngleLeft,
308                m_limitAngleRight,
309                m_limitAngleUp,
310                m_limitAngleDown,
311                m_headIndex,
312                m_neckIndex,
313                m_isOn,
314                m_individualLimitsOn,
315                m_isTargetInsideLimitCone,
316                __ignore,
317            }
318            struct __FieldVisitor;
319            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
320                type Value = __Field;
321                fn expecting(
322                    &self,
323                    __formatter: &mut core::fmt::Formatter,
324                ) -> core::fmt::Result {
325                    core::fmt::Formatter::write_str(__formatter, "field identifier")
326                }
327                /// Intended for use in XML.
328                #[allow(clippy::match_single_binding)]
329                #[allow(clippy::reversed_empty_ranges)]
330                #[allow(clippy::single_match)]
331                fn visit_key<__E>(
332                    self,
333                    __value: &str,
334                ) -> core::result::Result<Self::Value, __E>
335                where
336                    __E: _serde::de::Error,
337                {
338                    match __value {
339                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
340                        "userData" => Ok(__Field::m_userData),
341                        "name" => Ok(__Field::m_name),
342                        "enable" => Ok(__Field::m_enable),
343                        "targetWS" => Ok(__Field::m_targetWS),
344                        "headForwardLS" => Ok(__Field::m_headForwardLS),
345                        "neckForwardLS" => Ok(__Field::m_neckForwardLS),
346                        "neckRightLS" => Ok(__Field::m_neckRightLS),
347                        "eyePositionHS" => Ok(__Field::m_eyePositionHS),
348                        "newTargetGain" => Ok(__Field::m_newTargetGain),
349                        "onGain" => Ok(__Field::m_onGain),
350                        "offGain" => Ok(__Field::m_offGain),
351                        "limitAngleDegrees" => Ok(__Field::m_limitAngleDegrees),
352                        "limitAngleLeft" => Ok(__Field::m_limitAngleLeft),
353                        "limitAngleRight" => Ok(__Field::m_limitAngleRight),
354                        "limitAngleUp" => Ok(__Field::m_limitAngleUp),
355                        "limitAngleDown" => Ok(__Field::m_limitAngleDown),
356                        "headIndex" => Ok(__Field::m_headIndex),
357                        "neckIndex" => Ok(__Field::m_neckIndex),
358                        "isOn" => Ok(__Field::m_isOn),
359                        "individualLimitsOn" => Ok(__Field::m_individualLimitsOn),
360                        "isTargetInsideLimitCone" => {
361                            Ok(__Field::m_isTargetInsideLimitCone)
362                        }
363                        _ => Ok(__Field::__ignore),
364                    }
365                }
366            }
367            impl<'de> _serde::Deserialize<'de> for __Field {
368                #[inline]
369                fn deserialize<__D>(
370                    __deserializer: __D,
371                ) -> core::result::Result<Self, __D::Error>
372                where
373                    __D: _serde::Deserializer<'de>,
374                {
375                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
376                }
377            }
378            struct __hkbLookAtModifierVisitor<'de> {
379                marker: _serde::__private::PhantomData<hkbLookAtModifier<'de>>,
380                lifetime: _serde::__private::PhantomData<&'de ()>,
381            }
382            #[allow(clippy::match_single_binding)]
383            #[allow(clippy::reversed_empty_ranges)]
384            #[allow(clippy::single_match)]
385            impl<'de> _serde::de::Visitor<'de> for __hkbLookAtModifierVisitor<'de> {
386                type Value = hkbLookAtModifier<'de>;
387                fn expecting(
388                    &self,
389                    __formatter: &mut core::fmt::Formatter,
390                ) -> core::fmt::Result {
391                    core::fmt::Formatter::write_str(
392                        __formatter,
393                        "struct hkbLookAtModifier",
394                    )
395                }
396                fn visit_struct_for_bytes<__A>(
397                    self,
398                    mut __map: __A,
399                ) -> _serde::__private::Result<Self::Value, __A::Error>
400                where
401                    __A: _serde::de::MapAccess<'de>,
402                {
403                    let __ptr = __A::class_ptr(&mut __map);
404                    let parent = __A::parent_value(&mut __map)?;
405                    let mut m_targetWS: _serde::__private::Option<Vector4> = _serde::__private::None;
406                    let mut m_headForwardLS: _serde::__private::Option<Vector4> = _serde::__private::None;
407                    let mut m_neckForwardLS: _serde::__private::Option<Vector4> = _serde::__private::None;
408                    let mut m_neckRightLS: _serde::__private::Option<Vector4> = _serde::__private::None;
409                    let mut m_eyePositionHS: _serde::__private::Option<Vector4> = _serde::__private::None;
410                    let mut m_newTargetGain: _serde::__private::Option<f32> = _serde::__private::None;
411                    let mut m_onGain: _serde::__private::Option<f32> = _serde::__private::None;
412                    let mut m_offGain: _serde::__private::Option<f32> = _serde::__private::None;
413                    let mut m_limitAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
414                    let mut m_limitAngleLeft: _serde::__private::Option<f32> = _serde::__private::None;
415                    let mut m_limitAngleRight: _serde::__private::Option<f32> = _serde::__private::None;
416                    let mut m_limitAngleUp: _serde::__private::Option<f32> = _serde::__private::None;
417                    let mut m_limitAngleDown: _serde::__private::Option<f32> = _serde::__private::None;
418                    let mut m_headIndex: _serde::__private::Option<i16> = _serde::__private::None;
419                    let mut m_neckIndex: _serde::__private::Option<i16> = _serde::__private::None;
420                    let mut m_isOn: _serde::__private::Option<bool> = _serde::__private::None;
421                    let mut m_individualLimitsOn: _serde::__private::Option<bool> = _serde::__private::None;
422                    let mut m_isTargetInsideLimitCone: _serde::__private::Option<bool> = _serde::__private::None;
423                    let mut m_lookAtLastTargetWS: _serde::__private::Option<Vector4> = _serde::__private::None;
424                    let mut m_lookAtWeight: _serde::__private::Option<f32> = _serde::__private::None;
425                    for i in 0..20usize {
426                        match i {
427                            0usize => {
428                                if _serde::__private::Option::is_some(&m_targetWS) {
429                                    return _serde::__private::Err(
430                                        <__A::Error as _serde::de::Error>::duplicate_field(
431                                            "targetWS",
432                                        ),
433                                    );
434                                }
435                                __A::pad(&mut __map, 4usize, 0usize)?;
436                                m_targetWS = _serde::__private::Some(
437                                    match __A::next_value::<Vector4>(&mut __map) {
438                                        _serde::__private::Ok(__val) => __val,
439                                        _serde::__private::Err(__err) => {
440                                            return _serde::__private::Err(__err);
441                                        }
442                                    },
443                                );
444                            }
445                            1usize => {
446                                if _serde::__private::Option::is_some(&m_headForwardLS) {
447                                    return _serde::__private::Err(
448                                        <__A::Error as _serde::de::Error>::duplicate_field(
449                                            "headForwardLS",
450                                        ),
451                                    );
452                                }
453                                m_headForwardLS = _serde::__private::Some(
454                                    match __A::next_value::<Vector4>(&mut __map) {
455                                        _serde::__private::Ok(__val) => __val,
456                                        _serde::__private::Err(__err) => {
457                                            return _serde::__private::Err(__err);
458                                        }
459                                    },
460                                );
461                            }
462                            2usize => {
463                                if _serde::__private::Option::is_some(&m_neckForwardLS) {
464                                    return _serde::__private::Err(
465                                        <__A::Error as _serde::de::Error>::duplicate_field(
466                                            "neckForwardLS",
467                                        ),
468                                    );
469                                }
470                                m_neckForwardLS = _serde::__private::Some(
471                                    match __A::next_value::<Vector4>(&mut __map) {
472                                        _serde::__private::Ok(__val) => __val,
473                                        _serde::__private::Err(__err) => {
474                                            return _serde::__private::Err(__err);
475                                        }
476                                    },
477                                );
478                            }
479                            3usize => {
480                                if _serde::__private::Option::is_some(&m_neckRightLS) {
481                                    return _serde::__private::Err(
482                                        <__A::Error as _serde::de::Error>::duplicate_field(
483                                            "neckRightLS",
484                                        ),
485                                    );
486                                }
487                                m_neckRightLS = _serde::__private::Some(
488                                    match __A::next_value::<Vector4>(&mut __map) {
489                                        _serde::__private::Ok(__val) => __val,
490                                        _serde::__private::Err(__err) => {
491                                            return _serde::__private::Err(__err);
492                                        }
493                                    },
494                                );
495                            }
496                            4usize => {
497                                if _serde::__private::Option::is_some(&m_eyePositionHS) {
498                                    return _serde::__private::Err(
499                                        <__A::Error as _serde::de::Error>::duplicate_field(
500                                            "eyePositionHS",
501                                        ),
502                                    );
503                                }
504                                m_eyePositionHS = _serde::__private::Some(
505                                    match __A::next_value::<Vector4>(&mut __map) {
506                                        _serde::__private::Ok(__val) => __val,
507                                        _serde::__private::Err(__err) => {
508                                            return _serde::__private::Err(__err);
509                                        }
510                                    },
511                                );
512                            }
513                            5usize => {
514                                if _serde::__private::Option::is_some(&m_newTargetGain) {
515                                    return _serde::__private::Err(
516                                        <__A::Error as _serde::de::Error>::duplicate_field(
517                                            "newTargetGain",
518                                        ),
519                                    );
520                                }
521                                m_newTargetGain = _serde::__private::Some(
522                                    match __A::next_value::<f32>(&mut __map) {
523                                        _serde::__private::Ok(__val) => __val,
524                                        _serde::__private::Err(__err) => {
525                                            return _serde::__private::Err(__err);
526                                        }
527                                    },
528                                );
529                            }
530                            6usize => {
531                                if _serde::__private::Option::is_some(&m_onGain) {
532                                    return _serde::__private::Err(
533                                        <__A::Error as _serde::de::Error>::duplicate_field("onGain"),
534                                    );
535                                }
536                                m_onGain = _serde::__private::Some(
537                                    match __A::next_value::<f32>(&mut __map) {
538                                        _serde::__private::Ok(__val) => __val,
539                                        _serde::__private::Err(__err) => {
540                                            return _serde::__private::Err(__err);
541                                        }
542                                    },
543                                );
544                            }
545                            7usize => {
546                                if _serde::__private::Option::is_some(&m_offGain) {
547                                    return _serde::__private::Err(
548                                        <__A::Error as _serde::de::Error>::duplicate_field(
549                                            "offGain",
550                                        ),
551                                    );
552                                }
553                                m_offGain = _serde::__private::Some(
554                                    match __A::next_value::<f32>(&mut __map) {
555                                        _serde::__private::Ok(__val) => __val,
556                                        _serde::__private::Err(__err) => {
557                                            return _serde::__private::Err(__err);
558                                        }
559                                    },
560                                );
561                            }
562                            8usize => {
563                                if _serde::__private::Option::is_some(
564                                    &m_limitAngleDegrees,
565                                ) {
566                                    return _serde::__private::Err(
567                                        <__A::Error as _serde::de::Error>::duplicate_field(
568                                            "limitAngleDegrees",
569                                        ),
570                                    );
571                                }
572                                m_limitAngleDegrees = _serde::__private::Some(
573                                    match __A::next_value::<f32>(&mut __map) {
574                                        _serde::__private::Ok(__val) => __val,
575                                        _serde::__private::Err(__err) => {
576                                            return _serde::__private::Err(__err);
577                                        }
578                                    },
579                                );
580                            }
581                            9usize => {
582                                if _serde::__private::Option::is_some(&m_limitAngleLeft) {
583                                    return _serde::__private::Err(
584                                        <__A::Error as _serde::de::Error>::duplicate_field(
585                                            "limitAngleLeft",
586                                        ),
587                                    );
588                                }
589                                m_limitAngleLeft = _serde::__private::Some(
590                                    match __A::next_value::<f32>(&mut __map) {
591                                        _serde::__private::Ok(__val) => __val,
592                                        _serde::__private::Err(__err) => {
593                                            return _serde::__private::Err(__err);
594                                        }
595                                    },
596                                );
597                            }
598                            10usize => {
599                                if _serde::__private::Option::is_some(&m_limitAngleRight) {
600                                    return _serde::__private::Err(
601                                        <__A::Error as _serde::de::Error>::duplicate_field(
602                                            "limitAngleRight",
603                                        ),
604                                    );
605                                }
606                                m_limitAngleRight = _serde::__private::Some(
607                                    match __A::next_value::<f32>(&mut __map) {
608                                        _serde::__private::Ok(__val) => __val,
609                                        _serde::__private::Err(__err) => {
610                                            return _serde::__private::Err(__err);
611                                        }
612                                    },
613                                );
614                            }
615                            11usize => {
616                                if _serde::__private::Option::is_some(&m_limitAngleUp) {
617                                    return _serde::__private::Err(
618                                        <__A::Error as _serde::de::Error>::duplicate_field(
619                                            "limitAngleUp",
620                                        ),
621                                    );
622                                }
623                                m_limitAngleUp = _serde::__private::Some(
624                                    match __A::next_value::<f32>(&mut __map) {
625                                        _serde::__private::Ok(__val) => __val,
626                                        _serde::__private::Err(__err) => {
627                                            return _serde::__private::Err(__err);
628                                        }
629                                    },
630                                );
631                            }
632                            12usize => {
633                                if _serde::__private::Option::is_some(&m_limitAngleDown) {
634                                    return _serde::__private::Err(
635                                        <__A::Error as _serde::de::Error>::duplicate_field(
636                                            "limitAngleDown",
637                                        ),
638                                    );
639                                }
640                                m_limitAngleDown = _serde::__private::Some(
641                                    match __A::next_value::<f32>(&mut __map) {
642                                        _serde::__private::Ok(__val) => __val,
643                                        _serde::__private::Err(__err) => {
644                                            return _serde::__private::Err(__err);
645                                        }
646                                    },
647                                );
648                            }
649                            13usize => {
650                                if _serde::__private::Option::is_some(&m_headIndex) {
651                                    return _serde::__private::Err(
652                                        <__A::Error as _serde::de::Error>::duplicate_field(
653                                            "headIndex",
654                                        ),
655                                    );
656                                }
657                                m_headIndex = _serde::__private::Some(
658                                    match __A::next_value::<i16>(&mut __map) {
659                                        _serde::__private::Ok(__val) => __val,
660                                        _serde::__private::Err(__err) => {
661                                            return _serde::__private::Err(__err);
662                                        }
663                                    },
664                                );
665                            }
666                            14usize => {
667                                if _serde::__private::Option::is_some(&m_neckIndex) {
668                                    return _serde::__private::Err(
669                                        <__A::Error as _serde::de::Error>::duplicate_field(
670                                            "neckIndex",
671                                        ),
672                                    );
673                                }
674                                m_neckIndex = _serde::__private::Some(
675                                    match __A::next_value::<i16>(&mut __map) {
676                                        _serde::__private::Ok(__val) => __val,
677                                        _serde::__private::Err(__err) => {
678                                            return _serde::__private::Err(__err);
679                                        }
680                                    },
681                                );
682                            }
683                            15usize => {
684                                if _serde::__private::Option::is_some(&m_isOn) {
685                                    return _serde::__private::Err(
686                                        <__A::Error as _serde::de::Error>::duplicate_field("isOn"),
687                                    );
688                                }
689                                m_isOn = _serde::__private::Some(
690                                    match __A::next_value::<bool>(&mut __map) {
691                                        _serde::__private::Ok(__val) => __val,
692                                        _serde::__private::Err(__err) => {
693                                            return _serde::__private::Err(__err);
694                                        }
695                                    },
696                                );
697                            }
698                            16usize => {
699                                if _serde::__private::Option::is_some(
700                                    &m_individualLimitsOn,
701                                ) {
702                                    return _serde::__private::Err(
703                                        <__A::Error as _serde::de::Error>::duplicate_field(
704                                            "individualLimitsOn",
705                                        ),
706                                    );
707                                }
708                                m_individualLimitsOn = _serde::__private::Some(
709                                    match __A::next_value::<bool>(&mut __map) {
710                                        _serde::__private::Ok(__val) => __val,
711                                        _serde::__private::Err(__err) => {
712                                            return _serde::__private::Err(__err);
713                                        }
714                                    },
715                                );
716                            }
717                            17usize => {
718                                if _serde::__private::Option::is_some(
719                                    &m_isTargetInsideLimitCone,
720                                ) {
721                                    return _serde::__private::Err(
722                                        <__A::Error as _serde::de::Error>::duplicate_field(
723                                            "isTargetInsideLimitCone",
724                                        ),
725                                    );
726                                }
727                                m_isTargetInsideLimitCone = _serde::__private::Some(
728                                    match __A::next_value::<bool>(&mut __map) {
729                                        _serde::__private::Ok(__val) => __val,
730                                        _serde::__private::Err(__err) => {
731                                            return _serde::__private::Err(__err);
732                                        }
733                                    },
734                                );
735                            }
736                            18usize => {
737                                if _serde::__private::Option::is_some(
738                                    &m_lookAtLastTargetWS,
739                                ) {
740                                    return _serde::__private::Err(
741                                        <__A::Error as _serde::de::Error>::duplicate_field(
742                                            "lookAtLastTargetWS",
743                                        ),
744                                    );
745                                }
746                                __A::pad(&mut __map, 9usize, 9usize)?;
747                                m_lookAtLastTargetWS = _serde::__private::Some(
748                                    match __A::next_value::<Vector4>(&mut __map) {
749                                        _serde::__private::Ok(__val) => __val,
750                                        _serde::__private::Err(__err) => {
751                                            return _serde::__private::Err(__err);
752                                        }
753                                    },
754                                );
755                            }
756                            19usize => {
757                                if _serde::__private::Option::is_some(&m_lookAtWeight) {
758                                    return _serde::__private::Err(
759                                        <__A::Error as _serde::de::Error>::duplicate_field(
760                                            "lookAtWeight",
761                                        ),
762                                    );
763                                }
764                                m_lookAtWeight = _serde::__private::Some(
765                                    match __A::next_value::<f32>(&mut __map) {
766                                        _serde::__private::Ok(__val) => __val,
767                                        _serde::__private::Err(__err) => {
768                                            return _serde::__private::Err(__err);
769                                        }
770                                    },
771                                );
772                            }
773                            _ => {}
774                        }
775                    }
776                    __A::pad(&mut __map, 12usize, 12usize)?;
777                    let m_targetWS = match m_targetWS {
778                        _serde::__private::Some(__field) => __field,
779                        _serde::__private::None => {
780                            return _serde::__private::Err(
781                                <__A::Error as _serde::de::Error>::missing_field("targetWS"),
782                            );
783                        }
784                    };
785                    let m_headForwardLS = match m_headForwardLS {
786                        _serde::__private::Some(__field) => __field,
787                        _serde::__private::None => {
788                            return _serde::__private::Err(
789                                <__A::Error as _serde::de::Error>::missing_field(
790                                    "headForwardLS",
791                                ),
792                            );
793                        }
794                    };
795                    let m_neckForwardLS = match m_neckForwardLS {
796                        _serde::__private::Some(__field) => __field,
797                        _serde::__private::None => {
798                            return _serde::__private::Err(
799                                <__A::Error as _serde::de::Error>::missing_field(
800                                    "neckForwardLS",
801                                ),
802                            );
803                        }
804                    };
805                    let m_neckRightLS = match m_neckRightLS {
806                        _serde::__private::Some(__field) => __field,
807                        _serde::__private::None => {
808                            return _serde::__private::Err(
809                                <__A::Error as _serde::de::Error>::missing_field(
810                                    "neckRightLS",
811                                ),
812                            );
813                        }
814                    };
815                    let m_eyePositionHS = match m_eyePositionHS {
816                        _serde::__private::Some(__field) => __field,
817                        _serde::__private::None => {
818                            return _serde::__private::Err(
819                                <__A::Error as _serde::de::Error>::missing_field(
820                                    "eyePositionHS",
821                                ),
822                            );
823                        }
824                    };
825                    let m_newTargetGain = match m_newTargetGain {
826                        _serde::__private::Some(__field) => __field,
827                        _serde::__private::None => {
828                            return _serde::__private::Err(
829                                <__A::Error as _serde::de::Error>::missing_field(
830                                    "newTargetGain",
831                                ),
832                            );
833                        }
834                    };
835                    let m_onGain = match m_onGain {
836                        _serde::__private::Some(__field) => __field,
837                        _serde::__private::None => {
838                            return _serde::__private::Err(
839                                <__A::Error as _serde::de::Error>::missing_field("onGain"),
840                            );
841                        }
842                    };
843                    let m_offGain = match m_offGain {
844                        _serde::__private::Some(__field) => __field,
845                        _serde::__private::None => {
846                            return _serde::__private::Err(
847                                <__A::Error as _serde::de::Error>::missing_field("offGain"),
848                            );
849                        }
850                    };
851                    let m_limitAngleDegrees = match m_limitAngleDegrees {
852                        _serde::__private::Some(__field) => __field,
853                        _serde::__private::None => {
854                            return _serde::__private::Err(
855                                <__A::Error as _serde::de::Error>::missing_field(
856                                    "limitAngleDegrees",
857                                ),
858                            );
859                        }
860                    };
861                    let m_limitAngleLeft = match m_limitAngleLeft {
862                        _serde::__private::Some(__field) => __field,
863                        _serde::__private::None => {
864                            return _serde::__private::Err(
865                                <__A::Error as _serde::de::Error>::missing_field(
866                                    "limitAngleLeft",
867                                ),
868                            );
869                        }
870                    };
871                    let m_limitAngleRight = match m_limitAngleRight {
872                        _serde::__private::Some(__field) => __field,
873                        _serde::__private::None => {
874                            return _serde::__private::Err(
875                                <__A::Error as _serde::de::Error>::missing_field(
876                                    "limitAngleRight",
877                                ),
878                            );
879                        }
880                    };
881                    let m_limitAngleUp = match m_limitAngleUp {
882                        _serde::__private::Some(__field) => __field,
883                        _serde::__private::None => {
884                            return _serde::__private::Err(
885                                <__A::Error as _serde::de::Error>::missing_field(
886                                    "limitAngleUp",
887                                ),
888                            );
889                        }
890                    };
891                    let m_limitAngleDown = match m_limitAngleDown {
892                        _serde::__private::Some(__field) => __field,
893                        _serde::__private::None => {
894                            return _serde::__private::Err(
895                                <__A::Error as _serde::de::Error>::missing_field(
896                                    "limitAngleDown",
897                                ),
898                            );
899                        }
900                    };
901                    let m_headIndex = match m_headIndex {
902                        _serde::__private::Some(__field) => __field,
903                        _serde::__private::None => {
904                            return _serde::__private::Err(
905                                <__A::Error as _serde::de::Error>::missing_field(
906                                    "headIndex",
907                                ),
908                            );
909                        }
910                    };
911                    let m_neckIndex = match m_neckIndex {
912                        _serde::__private::Some(__field) => __field,
913                        _serde::__private::None => {
914                            return _serde::__private::Err(
915                                <__A::Error as _serde::de::Error>::missing_field(
916                                    "neckIndex",
917                                ),
918                            );
919                        }
920                    };
921                    let m_isOn = match m_isOn {
922                        _serde::__private::Some(__field) => __field,
923                        _serde::__private::None => {
924                            return _serde::__private::Err(
925                                <__A::Error as _serde::de::Error>::missing_field("isOn"),
926                            );
927                        }
928                    };
929                    let m_individualLimitsOn = match m_individualLimitsOn {
930                        _serde::__private::Some(__field) => __field,
931                        _serde::__private::None => {
932                            return _serde::__private::Err(
933                                <__A::Error as _serde::de::Error>::missing_field(
934                                    "individualLimitsOn",
935                                ),
936                            );
937                        }
938                    };
939                    let m_isTargetInsideLimitCone = match m_isTargetInsideLimitCone {
940                        _serde::__private::Some(__field) => __field,
941                        _serde::__private::None => {
942                            return _serde::__private::Err(
943                                <__A::Error as _serde::de::Error>::missing_field(
944                                    "isTargetInsideLimitCone",
945                                ),
946                            );
947                        }
948                    };
949                    let m_lookAtLastTargetWS = match m_lookAtLastTargetWS {
950                        _serde::__private::Some(__field) => __field,
951                        _serde::__private::None => {
952                            return _serde::__private::Err(
953                                <__A::Error as _serde::de::Error>::missing_field(
954                                    "lookAtLastTargetWS",
955                                ),
956                            );
957                        }
958                    };
959                    let m_lookAtWeight = match m_lookAtWeight {
960                        _serde::__private::Some(__field) => __field,
961                        _serde::__private::None => {
962                            return _serde::__private::Err(
963                                <__A::Error as _serde::de::Error>::missing_field(
964                                    "lookAtWeight",
965                                ),
966                            );
967                        }
968                    };
969                    _serde::__private::Ok(hkbLookAtModifier {
970                        __ptr,
971                        parent,
972                        m_targetWS,
973                        m_headForwardLS,
974                        m_neckForwardLS,
975                        m_neckRightLS,
976                        m_eyePositionHS,
977                        m_newTargetGain,
978                        m_onGain,
979                        m_offGain,
980                        m_limitAngleDegrees,
981                        m_limitAngleLeft,
982                        m_limitAngleRight,
983                        m_limitAngleUp,
984                        m_limitAngleDown,
985                        m_headIndex,
986                        m_neckIndex,
987                        m_isOn,
988                        m_individualLimitsOn,
989                        m_isTargetInsideLimitCone,
990                        m_lookAtLastTargetWS,
991                        m_lookAtWeight,
992                    })
993                }
994                #[allow(clippy::manual_unwrap_or_default)]
995                fn visit_struct<__A>(
996                    self,
997                    mut __map: __A,
998                ) -> _serde::__private::Result<Self::Value, __A::Error>
999                where
1000                    __A: _serde::de::MapAccess<'de>,
1001                {
1002                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1003                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1004                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1005                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
1006                    let mut m_targetWS: _serde::__private::Option<Vector4> = _serde::__private::None;
1007                    let mut m_headForwardLS: _serde::__private::Option<Vector4> = _serde::__private::None;
1008                    let mut m_neckForwardLS: _serde::__private::Option<Vector4> = _serde::__private::None;
1009                    let mut m_neckRightLS: _serde::__private::Option<Vector4> = _serde::__private::None;
1010                    let mut m_eyePositionHS: _serde::__private::Option<Vector4> = _serde::__private::None;
1011                    let mut m_newTargetGain: _serde::__private::Option<f32> = _serde::__private::None;
1012                    let mut m_onGain: _serde::__private::Option<f32> = _serde::__private::None;
1013                    let mut m_offGain: _serde::__private::Option<f32> = _serde::__private::None;
1014                    let mut m_limitAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
1015                    let mut m_limitAngleLeft: _serde::__private::Option<f32> = _serde::__private::None;
1016                    let mut m_limitAngleRight: _serde::__private::Option<f32> = _serde::__private::None;
1017                    let mut m_limitAngleUp: _serde::__private::Option<f32> = _serde::__private::None;
1018                    let mut m_limitAngleDown: _serde::__private::Option<f32> = _serde::__private::None;
1019                    let mut m_headIndex: _serde::__private::Option<i16> = _serde::__private::None;
1020                    let mut m_neckIndex: _serde::__private::Option<i16> = _serde::__private::None;
1021                    let mut m_isOn: _serde::__private::Option<bool> = _serde::__private::None;
1022                    let mut m_individualLimitsOn: _serde::__private::Option<bool> = _serde::__private::None;
1023                    let mut m_isTargetInsideLimitCone: _serde::__private::Option<bool> = _serde::__private::None;
1024                    while let _serde::__private::Some(__key) = {
1025                        __A::next_key::<__Field>(&mut __map)?
1026                    } {
1027                        match __key {
1028                            __Field::m_variableBindingSet => {
1029                                #[cfg(
1030                                    any(feature = "strict", feature = "ignore_duplicates")
1031                                )]
1032                                if _serde::__private::Option::is_some(
1033                                    &m_variableBindingSet,
1034                                ) {
1035                                    #[cfg(feature = "ignore_duplicates")]
1036                                    {
1037                                        __A::skip_value(&mut __map)?;
1038                                        continue;
1039                                    }
1040                                    #[cfg(feature = "strict")]
1041                                    return _serde::__private::Err(
1042                                        <__A::Error as _serde::de::Error>::duplicate_field(
1043                                            "variableBindingSet",
1044                                        ),
1045                                    );
1046                                }
1047                                m_variableBindingSet = _serde::__private::Some(
1048                                    match __A::next_value::<Pointer>(&mut __map) {
1049                                        _serde::__private::Ok(__val) => __val,
1050                                        _serde::__private::Err(__err) => {
1051                                            return _serde::__private::Err(__err);
1052                                        }
1053                                    },
1054                                );
1055                            }
1056                            __Field::m_userData => {
1057                                #[cfg(
1058                                    any(feature = "strict", feature = "ignore_duplicates")
1059                                )]
1060                                if _serde::__private::Option::is_some(&m_userData) {
1061                                    #[cfg(feature = "ignore_duplicates")]
1062                                    {
1063                                        __A::skip_value(&mut __map)?;
1064                                        continue;
1065                                    }
1066                                    #[cfg(feature = "strict")]
1067                                    return _serde::__private::Err(
1068                                        <__A::Error as _serde::de::Error>::duplicate_field(
1069                                            "userData",
1070                                        ),
1071                                    );
1072                                }
1073                                m_userData = _serde::__private::Some(
1074                                    match __A::next_value::<Ulong>(&mut __map) {
1075                                        _serde::__private::Ok(__val) => __val,
1076                                        _serde::__private::Err(__err) => {
1077                                            return _serde::__private::Err(__err);
1078                                        }
1079                                    },
1080                                );
1081                            }
1082                            __Field::m_name => {
1083                                #[cfg(
1084                                    any(feature = "strict", feature = "ignore_duplicates")
1085                                )]
1086                                if _serde::__private::Option::is_some(&m_name) {
1087                                    #[cfg(feature = "ignore_duplicates")]
1088                                    {
1089                                        __A::skip_value(&mut __map)?;
1090                                        continue;
1091                                    }
1092                                    #[cfg(feature = "strict")]
1093                                    return _serde::__private::Err(
1094                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
1095                                    );
1096                                }
1097                                m_name = _serde::__private::Some(
1098                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
1099                                        _serde::__private::Ok(__val) => __val,
1100                                        _serde::__private::Err(__err) => {
1101                                            return _serde::__private::Err(__err);
1102                                        }
1103                                    },
1104                                );
1105                            }
1106                            __Field::m_enable => {
1107                                #[cfg(
1108                                    any(feature = "strict", feature = "ignore_duplicates")
1109                                )]
1110                                if _serde::__private::Option::is_some(&m_enable) {
1111                                    #[cfg(feature = "ignore_duplicates")]
1112                                    {
1113                                        __A::skip_value(&mut __map)?;
1114                                        continue;
1115                                    }
1116                                    #[cfg(feature = "strict")]
1117                                    return _serde::__private::Err(
1118                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
1119                                    );
1120                                }
1121                                m_enable = _serde::__private::Some(
1122                                    match __A::next_value::<bool>(&mut __map) {
1123                                        _serde::__private::Ok(__val) => __val,
1124                                        _serde::__private::Err(__err) => {
1125                                            return _serde::__private::Err(__err);
1126                                        }
1127                                    },
1128                                );
1129                            }
1130                            __Field::m_targetWS => {
1131                                #[cfg(
1132                                    any(feature = "strict", feature = "ignore_duplicates")
1133                                )]
1134                                if _serde::__private::Option::is_some(&m_targetWS) {
1135                                    #[cfg(feature = "ignore_duplicates")]
1136                                    {
1137                                        __A::skip_value(&mut __map)?;
1138                                        continue;
1139                                    }
1140                                    #[cfg(feature = "strict")]
1141                                    return _serde::__private::Err(
1142                                        <__A::Error as _serde::de::Error>::duplicate_field(
1143                                            "targetWS",
1144                                        ),
1145                                    );
1146                                }
1147                                m_targetWS = _serde::__private::Some(
1148                                    match __A::next_value::<Vector4>(&mut __map) {
1149                                        _serde::__private::Ok(__val) => __val,
1150                                        _serde::__private::Err(__err) => {
1151                                            return _serde::__private::Err(__err);
1152                                        }
1153                                    },
1154                                );
1155                            }
1156                            __Field::m_headForwardLS => {
1157                                #[cfg(
1158                                    any(feature = "strict", feature = "ignore_duplicates")
1159                                )]
1160                                if _serde::__private::Option::is_some(&m_headForwardLS) {
1161                                    #[cfg(feature = "ignore_duplicates")]
1162                                    {
1163                                        __A::skip_value(&mut __map)?;
1164                                        continue;
1165                                    }
1166                                    #[cfg(feature = "strict")]
1167                                    return _serde::__private::Err(
1168                                        <__A::Error as _serde::de::Error>::duplicate_field(
1169                                            "headForwardLS",
1170                                        ),
1171                                    );
1172                                }
1173                                m_headForwardLS = _serde::__private::Some(
1174                                    match __A::next_value::<Vector4>(&mut __map) {
1175                                        _serde::__private::Ok(__val) => __val,
1176                                        _serde::__private::Err(__err) => {
1177                                            return _serde::__private::Err(__err);
1178                                        }
1179                                    },
1180                                );
1181                            }
1182                            __Field::m_neckForwardLS => {
1183                                #[cfg(
1184                                    any(feature = "strict", feature = "ignore_duplicates")
1185                                )]
1186                                if _serde::__private::Option::is_some(&m_neckForwardLS) {
1187                                    #[cfg(feature = "ignore_duplicates")]
1188                                    {
1189                                        __A::skip_value(&mut __map)?;
1190                                        continue;
1191                                    }
1192                                    #[cfg(feature = "strict")]
1193                                    return _serde::__private::Err(
1194                                        <__A::Error as _serde::de::Error>::duplicate_field(
1195                                            "neckForwardLS",
1196                                        ),
1197                                    );
1198                                }
1199                                m_neckForwardLS = _serde::__private::Some(
1200                                    match __A::next_value::<Vector4>(&mut __map) {
1201                                        _serde::__private::Ok(__val) => __val,
1202                                        _serde::__private::Err(__err) => {
1203                                            return _serde::__private::Err(__err);
1204                                        }
1205                                    },
1206                                );
1207                            }
1208                            __Field::m_neckRightLS => {
1209                                #[cfg(
1210                                    any(feature = "strict", feature = "ignore_duplicates")
1211                                )]
1212                                if _serde::__private::Option::is_some(&m_neckRightLS) {
1213                                    #[cfg(feature = "ignore_duplicates")]
1214                                    {
1215                                        __A::skip_value(&mut __map)?;
1216                                        continue;
1217                                    }
1218                                    #[cfg(feature = "strict")]
1219                                    return _serde::__private::Err(
1220                                        <__A::Error as _serde::de::Error>::duplicate_field(
1221                                            "neckRightLS",
1222                                        ),
1223                                    );
1224                                }
1225                                m_neckRightLS = _serde::__private::Some(
1226                                    match __A::next_value::<Vector4>(&mut __map) {
1227                                        _serde::__private::Ok(__val) => __val,
1228                                        _serde::__private::Err(__err) => {
1229                                            return _serde::__private::Err(__err);
1230                                        }
1231                                    },
1232                                );
1233                            }
1234                            __Field::m_eyePositionHS => {
1235                                #[cfg(
1236                                    any(feature = "strict", feature = "ignore_duplicates")
1237                                )]
1238                                if _serde::__private::Option::is_some(&m_eyePositionHS) {
1239                                    #[cfg(feature = "ignore_duplicates")]
1240                                    {
1241                                        __A::skip_value(&mut __map)?;
1242                                        continue;
1243                                    }
1244                                    #[cfg(feature = "strict")]
1245                                    return _serde::__private::Err(
1246                                        <__A::Error as _serde::de::Error>::duplicate_field(
1247                                            "eyePositionHS",
1248                                        ),
1249                                    );
1250                                }
1251                                m_eyePositionHS = _serde::__private::Some(
1252                                    match __A::next_value::<Vector4>(&mut __map) {
1253                                        _serde::__private::Ok(__val) => __val,
1254                                        _serde::__private::Err(__err) => {
1255                                            return _serde::__private::Err(__err);
1256                                        }
1257                                    },
1258                                );
1259                            }
1260                            __Field::m_newTargetGain => {
1261                                #[cfg(
1262                                    any(feature = "strict", feature = "ignore_duplicates")
1263                                )]
1264                                if _serde::__private::Option::is_some(&m_newTargetGain) {
1265                                    #[cfg(feature = "ignore_duplicates")]
1266                                    {
1267                                        __A::skip_value(&mut __map)?;
1268                                        continue;
1269                                    }
1270                                    #[cfg(feature = "strict")]
1271                                    return _serde::__private::Err(
1272                                        <__A::Error as _serde::de::Error>::duplicate_field(
1273                                            "newTargetGain",
1274                                        ),
1275                                    );
1276                                }
1277                                m_newTargetGain = _serde::__private::Some(
1278                                    match __A::next_value::<f32>(&mut __map) {
1279                                        _serde::__private::Ok(__val) => __val,
1280                                        _serde::__private::Err(__err) => {
1281                                            return _serde::__private::Err(__err);
1282                                        }
1283                                    },
1284                                );
1285                            }
1286                            __Field::m_onGain => {
1287                                #[cfg(
1288                                    any(feature = "strict", feature = "ignore_duplicates")
1289                                )]
1290                                if _serde::__private::Option::is_some(&m_onGain) {
1291                                    #[cfg(feature = "ignore_duplicates")]
1292                                    {
1293                                        __A::skip_value(&mut __map)?;
1294                                        continue;
1295                                    }
1296                                    #[cfg(feature = "strict")]
1297                                    return _serde::__private::Err(
1298                                        <__A::Error as _serde::de::Error>::duplicate_field("onGain"),
1299                                    );
1300                                }
1301                                m_onGain = _serde::__private::Some(
1302                                    match __A::next_value::<f32>(&mut __map) {
1303                                        _serde::__private::Ok(__val) => __val,
1304                                        _serde::__private::Err(__err) => {
1305                                            return _serde::__private::Err(__err);
1306                                        }
1307                                    },
1308                                );
1309                            }
1310                            __Field::m_offGain => {
1311                                #[cfg(
1312                                    any(feature = "strict", feature = "ignore_duplicates")
1313                                )]
1314                                if _serde::__private::Option::is_some(&m_offGain) {
1315                                    #[cfg(feature = "ignore_duplicates")]
1316                                    {
1317                                        __A::skip_value(&mut __map)?;
1318                                        continue;
1319                                    }
1320                                    #[cfg(feature = "strict")]
1321                                    return _serde::__private::Err(
1322                                        <__A::Error as _serde::de::Error>::duplicate_field(
1323                                            "offGain",
1324                                        ),
1325                                    );
1326                                }
1327                                m_offGain = _serde::__private::Some(
1328                                    match __A::next_value::<f32>(&mut __map) {
1329                                        _serde::__private::Ok(__val) => __val,
1330                                        _serde::__private::Err(__err) => {
1331                                            return _serde::__private::Err(__err);
1332                                        }
1333                                    },
1334                                );
1335                            }
1336                            __Field::m_limitAngleDegrees => {
1337                                #[cfg(
1338                                    any(feature = "strict", feature = "ignore_duplicates")
1339                                )]
1340                                if _serde::__private::Option::is_some(
1341                                    &m_limitAngleDegrees,
1342                                ) {
1343                                    #[cfg(feature = "ignore_duplicates")]
1344                                    {
1345                                        __A::skip_value(&mut __map)?;
1346                                        continue;
1347                                    }
1348                                    #[cfg(feature = "strict")]
1349                                    return _serde::__private::Err(
1350                                        <__A::Error as _serde::de::Error>::duplicate_field(
1351                                            "limitAngleDegrees",
1352                                        ),
1353                                    );
1354                                }
1355                                m_limitAngleDegrees = _serde::__private::Some(
1356                                    match __A::next_value::<f32>(&mut __map) {
1357                                        _serde::__private::Ok(__val) => __val,
1358                                        _serde::__private::Err(__err) => {
1359                                            return _serde::__private::Err(__err);
1360                                        }
1361                                    },
1362                                );
1363                            }
1364                            __Field::m_limitAngleLeft => {
1365                                #[cfg(
1366                                    any(feature = "strict", feature = "ignore_duplicates")
1367                                )]
1368                                if _serde::__private::Option::is_some(&m_limitAngleLeft) {
1369                                    #[cfg(feature = "ignore_duplicates")]
1370                                    {
1371                                        __A::skip_value(&mut __map)?;
1372                                        continue;
1373                                    }
1374                                    #[cfg(feature = "strict")]
1375                                    return _serde::__private::Err(
1376                                        <__A::Error as _serde::de::Error>::duplicate_field(
1377                                            "limitAngleLeft",
1378                                        ),
1379                                    );
1380                                }
1381                                m_limitAngleLeft = _serde::__private::Some(
1382                                    match __A::next_value::<f32>(&mut __map) {
1383                                        _serde::__private::Ok(__val) => __val,
1384                                        _serde::__private::Err(__err) => {
1385                                            return _serde::__private::Err(__err);
1386                                        }
1387                                    },
1388                                );
1389                            }
1390                            __Field::m_limitAngleRight => {
1391                                #[cfg(
1392                                    any(feature = "strict", feature = "ignore_duplicates")
1393                                )]
1394                                if _serde::__private::Option::is_some(&m_limitAngleRight) {
1395                                    #[cfg(feature = "ignore_duplicates")]
1396                                    {
1397                                        __A::skip_value(&mut __map)?;
1398                                        continue;
1399                                    }
1400                                    #[cfg(feature = "strict")]
1401                                    return _serde::__private::Err(
1402                                        <__A::Error as _serde::de::Error>::duplicate_field(
1403                                            "limitAngleRight",
1404                                        ),
1405                                    );
1406                                }
1407                                m_limitAngleRight = _serde::__private::Some(
1408                                    match __A::next_value::<f32>(&mut __map) {
1409                                        _serde::__private::Ok(__val) => __val,
1410                                        _serde::__private::Err(__err) => {
1411                                            return _serde::__private::Err(__err);
1412                                        }
1413                                    },
1414                                );
1415                            }
1416                            __Field::m_limitAngleUp => {
1417                                #[cfg(
1418                                    any(feature = "strict", feature = "ignore_duplicates")
1419                                )]
1420                                if _serde::__private::Option::is_some(&m_limitAngleUp) {
1421                                    #[cfg(feature = "ignore_duplicates")]
1422                                    {
1423                                        __A::skip_value(&mut __map)?;
1424                                        continue;
1425                                    }
1426                                    #[cfg(feature = "strict")]
1427                                    return _serde::__private::Err(
1428                                        <__A::Error as _serde::de::Error>::duplicate_field(
1429                                            "limitAngleUp",
1430                                        ),
1431                                    );
1432                                }
1433                                m_limitAngleUp = _serde::__private::Some(
1434                                    match __A::next_value::<f32>(&mut __map) {
1435                                        _serde::__private::Ok(__val) => __val,
1436                                        _serde::__private::Err(__err) => {
1437                                            return _serde::__private::Err(__err);
1438                                        }
1439                                    },
1440                                );
1441                            }
1442                            __Field::m_limitAngleDown => {
1443                                #[cfg(
1444                                    any(feature = "strict", feature = "ignore_duplicates")
1445                                )]
1446                                if _serde::__private::Option::is_some(&m_limitAngleDown) {
1447                                    #[cfg(feature = "ignore_duplicates")]
1448                                    {
1449                                        __A::skip_value(&mut __map)?;
1450                                        continue;
1451                                    }
1452                                    #[cfg(feature = "strict")]
1453                                    return _serde::__private::Err(
1454                                        <__A::Error as _serde::de::Error>::duplicate_field(
1455                                            "limitAngleDown",
1456                                        ),
1457                                    );
1458                                }
1459                                m_limitAngleDown = _serde::__private::Some(
1460                                    match __A::next_value::<f32>(&mut __map) {
1461                                        _serde::__private::Ok(__val) => __val,
1462                                        _serde::__private::Err(__err) => {
1463                                            return _serde::__private::Err(__err);
1464                                        }
1465                                    },
1466                                );
1467                            }
1468                            __Field::m_headIndex => {
1469                                #[cfg(
1470                                    any(feature = "strict", feature = "ignore_duplicates")
1471                                )]
1472                                if _serde::__private::Option::is_some(&m_headIndex) {
1473                                    #[cfg(feature = "ignore_duplicates")]
1474                                    {
1475                                        __A::skip_value(&mut __map)?;
1476                                        continue;
1477                                    }
1478                                    #[cfg(feature = "strict")]
1479                                    return _serde::__private::Err(
1480                                        <__A::Error as _serde::de::Error>::duplicate_field(
1481                                            "headIndex",
1482                                        ),
1483                                    );
1484                                }
1485                                m_headIndex = _serde::__private::Some(
1486                                    match __A::next_value::<i16>(&mut __map) {
1487                                        _serde::__private::Ok(__val) => __val,
1488                                        _serde::__private::Err(__err) => {
1489                                            return _serde::__private::Err(__err);
1490                                        }
1491                                    },
1492                                );
1493                            }
1494                            __Field::m_neckIndex => {
1495                                #[cfg(
1496                                    any(feature = "strict", feature = "ignore_duplicates")
1497                                )]
1498                                if _serde::__private::Option::is_some(&m_neckIndex) {
1499                                    #[cfg(feature = "ignore_duplicates")]
1500                                    {
1501                                        __A::skip_value(&mut __map)?;
1502                                        continue;
1503                                    }
1504                                    #[cfg(feature = "strict")]
1505                                    return _serde::__private::Err(
1506                                        <__A::Error as _serde::de::Error>::duplicate_field(
1507                                            "neckIndex",
1508                                        ),
1509                                    );
1510                                }
1511                                m_neckIndex = _serde::__private::Some(
1512                                    match __A::next_value::<i16>(&mut __map) {
1513                                        _serde::__private::Ok(__val) => __val,
1514                                        _serde::__private::Err(__err) => {
1515                                            return _serde::__private::Err(__err);
1516                                        }
1517                                    },
1518                                );
1519                            }
1520                            __Field::m_isOn => {
1521                                #[cfg(
1522                                    any(feature = "strict", feature = "ignore_duplicates")
1523                                )]
1524                                if _serde::__private::Option::is_some(&m_isOn) {
1525                                    #[cfg(feature = "ignore_duplicates")]
1526                                    {
1527                                        __A::skip_value(&mut __map)?;
1528                                        continue;
1529                                    }
1530                                    #[cfg(feature = "strict")]
1531                                    return _serde::__private::Err(
1532                                        <__A::Error as _serde::de::Error>::duplicate_field("isOn"),
1533                                    );
1534                                }
1535                                m_isOn = _serde::__private::Some(
1536                                    match __A::next_value::<bool>(&mut __map) {
1537                                        _serde::__private::Ok(__val) => __val,
1538                                        _serde::__private::Err(__err) => {
1539                                            return _serde::__private::Err(__err);
1540                                        }
1541                                    },
1542                                );
1543                            }
1544                            __Field::m_individualLimitsOn => {
1545                                #[cfg(
1546                                    any(feature = "strict", feature = "ignore_duplicates")
1547                                )]
1548                                if _serde::__private::Option::is_some(
1549                                    &m_individualLimitsOn,
1550                                ) {
1551                                    #[cfg(feature = "ignore_duplicates")]
1552                                    {
1553                                        __A::skip_value(&mut __map)?;
1554                                        continue;
1555                                    }
1556                                    #[cfg(feature = "strict")]
1557                                    return _serde::__private::Err(
1558                                        <__A::Error as _serde::de::Error>::duplicate_field(
1559                                            "individualLimitsOn",
1560                                        ),
1561                                    );
1562                                }
1563                                m_individualLimitsOn = _serde::__private::Some(
1564                                    match __A::next_value::<bool>(&mut __map) {
1565                                        _serde::__private::Ok(__val) => __val,
1566                                        _serde::__private::Err(__err) => {
1567                                            return _serde::__private::Err(__err);
1568                                        }
1569                                    },
1570                                );
1571                            }
1572                            __Field::m_isTargetInsideLimitCone => {
1573                                #[cfg(
1574                                    any(feature = "strict", feature = "ignore_duplicates")
1575                                )]
1576                                if _serde::__private::Option::is_some(
1577                                    &m_isTargetInsideLimitCone,
1578                                ) {
1579                                    #[cfg(feature = "ignore_duplicates")]
1580                                    {
1581                                        __A::skip_value(&mut __map)?;
1582                                        continue;
1583                                    }
1584                                    #[cfg(feature = "strict")]
1585                                    return _serde::__private::Err(
1586                                        <__A::Error as _serde::de::Error>::duplicate_field(
1587                                            "isTargetInsideLimitCone",
1588                                        ),
1589                                    );
1590                                }
1591                                m_isTargetInsideLimitCone = _serde::__private::Some(
1592                                    match __A::next_value::<bool>(&mut __map) {
1593                                        _serde::__private::Ok(__val) => __val,
1594                                        _serde::__private::Err(__err) => {
1595                                            return _serde::__private::Err(__err);
1596                                        }
1597                                    },
1598                                );
1599                            }
1600                            _ => __A::skip_value(&mut __map)?,
1601                        }
1602                    }
1603                    let m_variableBindingSet = match m_variableBindingSet {
1604                        _serde::__private::Some(__field) => __field,
1605                        _serde::__private::None => {
1606                            #[cfg(feature = "strict")]
1607                            return _serde::__private::Err(
1608                                <__A::Error as _serde::de::Error>::missing_field(
1609                                    "variableBindingSet",
1610                                ),
1611                            );
1612                            #[cfg(not(feature = "strict"))] Default::default()
1613                        }
1614                    };
1615                    let m_userData = match m_userData {
1616                        _serde::__private::Some(__field) => __field,
1617                        _serde::__private::None => {
1618                            #[cfg(feature = "strict")]
1619                            return _serde::__private::Err(
1620                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1621                            );
1622                            #[cfg(not(feature = "strict"))] Default::default()
1623                        }
1624                    };
1625                    let m_name = match m_name {
1626                        _serde::__private::Some(__field) => __field,
1627                        _serde::__private::None => {
1628                            #[cfg(feature = "strict")]
1629                            return _serde::__private::Err(
1630                                <__A::Error as _serde::de::Error>::missing_field("name"),
1631                            );
1632                            #[cfg(not(feature = "strict"))] Default::default()
1633                        }
1634                    };
1635                    let m_enable = match m_enable {
1636                        _serde::__private::Some(__field) => __field,
1637                        _serde::__private::None => {
1638                            #[cfg(feature = "strict")]
1639                            return _serde::__private::Err(
1640                                <__A::Error as _serde::de::Error>::missing_field("enable"),
1641                            );
1642                            #[cfg(not(feature = "strict"))] Default::default()
1643                        }
1644                    };
1645                    let m_targetWS = match m_targetWS {
1646                        _serde::__private::Some(__field) => __field,
1647                        _serde::__private::None => {
1648                            #[cfg(feature = "strict")]
1649                            return _serde::__private::Err(
1650                                <__A::Error as _serde::de::Error>::missing_field("targetWS"),
1651                            );
1652                            #[cfg(not(feature = "strict"))] Default::default()
1653                        }
1654                    };
1655                    let m_headForwardLS = match m_headForwardLS {
1656                        _serde::__private::Some(__field) => __field,
1657                        _serde::__private::None => {
1658                            #[cfg(feature = "strict")]
1659                            return _serde::__private::Err(
1660                                <__A::Error as _serde::de::Error>::missing_field(
1661                                    "headForwardLS",
1662                                ),
1663                            );
1664                            #[cfg(not(feature = "strict"))] Default::default()
1665                        }
1666                    };
1667                    let m_neckForwardLS = match m_neckForwardLS {
1668                        _serde::__private::Some(__field) => __field,
1669                        _serde::__private::None => {
1670                            #[cfg(feature = "strict")]
1671                            return _serde::__private::Err(
1672                                <__A::Error as _serde::de::Error>::missing_field(
1673                                    "neckForwardLS",
1674                                ),
1675                            );
1676                            #[cfg(not(feature = "strict"))] Default::default()
1677                        }
1678                    };
1679                    let m_neckRightLS = match m_neckRightLS {
1680                        _serde::__private::Some(__field) => __field,
1681                        _serde::__private::None => {
1682                            #[cfg(feature = "strict")]
1683                            return _serde::__private::Err(
1684                                <__A::Error as _serde::de::Error>::missing_field(
1685                                    "neckRightLS",
1686                                ),
1687                            );
1688                            #[cfg(not(feature = "strict"))] Default::default()
1689                        }
1690                    };
1691                    let m_eyePositionHS = match m_eyePositionHS {
1692                        _serde::__private::Some(__field) => __field,
1693                        _serde::__private::None => {
1694                            #[cfg(feature = "strict")]
1695                            return _serde::__private::Err(
1696                                <__A::Error as _serde::de::Error>::missing_field(
1697                                    "eyePositionHS",
1698                                ),
1699                            );
1700                            #[cfg(not(feature = "strict"))] Default::default()
1701                        }
1702                    };
1703                    let m_newTargetGain = match m_newTargetGain {
1704                        _serde::__private::Some(__field) => __field,
1705                        _serde::__private::None => {
1706                            #[cfg(feature = "strict")]
1707                            return _serde::__private::Err(
1708                                <__A::Error as _serde::de::Error>::missing_field(
1709                                    "newTargetGain",
1710                                ),
1711                            );
1712                            #[cfg(not(feature = "strict"))] Default::default()
1713                        }
1714                    };
1715                    let m_onGain = match m_onGain {
1716                        _serde::__private::Some(__field) => __field,
1717                        _serde::__private::None => {
1718                            #[cfg(feature = "strict")]
1719                            return _serde::__private::Err(
1720                                <__A::Error as _serde::de::Error>::missing_field("onGain"),
1721                            );
1722                            #[cfg(not(feature = "strict"))] Default::default()
1723                        }
1724                    };
1725                    let m_offGain = match m_offGain {
1726                        _serde::__private::Some(__field) => __field,
1727                        _serde::__private::None => {
1728                            #[cfg(feature = "strict")]
1729                            return _serde::__private::Err(
1730                                <__A::Error as _serde::de::Error>::missing_field("offGain"),
1731                            );
1732                            #[cfg(not(feature = "strict"))] Default::default()
1733                        }
1734                    };
1735                    let m_limitAngleDegrees = match m_limitAngleDegrees {
1736                        _serde::__private::Some(__field) => __field,
1737                        _serde::__private::None => {
1738                            #[cfg(feature = "strict")]
1739                            return _serde::__private::Err(
1740                                <__A::Error as _serde::de::Error>::missing_field(
1741                                    "limitAngleDegrees",
1742                                ),
1743                            );
1744                            #[cfg(not(feature = "strict"))] Default::default()
1745                        }
1746                    };
1747                    let m_limitAngleLeft = match m_limitAngleLeft {
1748                        _serde::__private::Some(__field) => __field,
1749                        _serde::__private::None => {
1750                            #[cfg(feature = "strict")]
1751                            return _serde::__private::Err(
1752                                <__A::Error as _serde::de::Error>::missing_field(
1753                                    "limitAngleLeft",
1754                                ),
1755                            );
1756                            #[cfg(not(feature = "strict"))] Default::default()
1757                        }
1758                    };
1759                    let m_limitAngleRight = match m_limitAngleRight {
1760                        _serde::__private::Some(__field) => __field,
1761                        _serde::__private::None => {
1762                            #[cfg(feature = "strict")]
1763                            return _serde::__private::Err(
1764                                <__A::Error as _serde::de::Error>::missing_field(
1765                                    "limitAngleRight",
1766                                ),
1767                            );
1768                            #[cfg(not(feature = "strict"))] Default::default()
1769                        }
1770                    };
1771                    let m_limitAngleUp = match m_limitAngleUp {
1772                        _serde::__private::Some(__field) => __field,
1773                        _serde::__private::None => {
1774                            #[cfg(feature = "strict")]
1775                            return _serde::__private::Err(
1776                                <__A::Error as _serde::de::Error>::missing_field(
1777                                    "limitAngleUp",
1778                                ),
1779                            );
1780                            #[cfg(not(feature = "strict"))] Default::default()
1781                        }
1782                    };
1783                    let m_limitAngleDown = match m_limitAngleDown {
1784                        _serde::__private::Some(__field) => __field,
1785                        _serde::__private::None => {
1786                            #[cfg(feature = "strict")]
1787                            return _serde::__private::Err(
1788                                <__A::Error as _serde::de::Error>::missing_field(
1789                                    "limitAngleDown",
1790                                ),
1791                            );
1792                            #[cfg(not(feature = "strict"))] Default::default()
1793                        }
1794                    };
1795                    let m_headIndex = match m_headIndex {
1796                        _serde::__private::Some(__field) => __field,
1797                        _serde::__private::None => {
1798                            #[cfg(feature = "strict")]
1799                            return _serde::__private::Err(
1800                                <__A::Error as _serde::de::Error>::missing_field(
1801                                    "headIndex",
1802                                ),
1803                            );
1804                            #[cfg(not(feature = "strict"))] Default::default()
1805                        }
1806                    };
1807                    let m_neckIndex = match m_neckIndex {
1808                        _serde::__private::Some(__field) => __field,
1809                        _serde::__private::None => {
1810                            #[cfg(feature = "strict")]
1811                            return _serde::__private::Err(
1812                                <__A::Error as _serde::de::Error>::missing_field(
1813                                    "neckIndex",
1814                                ),
1815                            );
1816                            #[cfg(not(feature = "strict"))] Default::default()
1817                        }
1818                    };
1819                    let m_isOn = match m_isOn {
1820                        _serde::__private::Some(__field) => __field,
1821                        _serde::__private::None => {
1822                            #[cfg(feature = "strict")]
1823                            return _serde::__private::Err(
1824                                <__A::Error as _serde::de::Error>::missing_field("isOn"),
1825                            );
1826                            #[cfg(not(feature = "strict"))] Default::default()
1827                        }
1828                    };
1829                    let m_individualLimitsOn = match m_individualLimitsOn {
1830                        _serde::__private::Some(__field) => __field,
1831                        _serde::__private::None => {
1832                            #[cfg(feature = "strict")]
1833                            return _serde::__private::Err(
1834                                <__A::Error as _serde::de::Error>::missing_field(
1835                                    "individualLimitsOn",
1836                                ),
1837                            );
1838                            #[cfg(not(feature = "strict"))] Default::default()
1839                        }
1840                    };
1841                    let m_isTargetInsideLimitCone = match m_isTargetInsideLimitCone {
1842                        _serde::__private::Some(__field) => __field,
1843                        _serde::__private::None => {
1844                            #[cfg(feature = "strict")]
1845                            return _serde::__private::Err(
1846                                <__A::Error as _serde::de::Error>::missing_field(
1847                                    "isTargetInsideLimitCone",
1848                                ),
1849                            );
1850                            #[cfg(not(feature = "strict"))] Default::default()
1851                        }
1852                    };
1853                    let __ptr = None;
1854                    let parent = hkBaseObject { __ptr };
1855                    let parent = hkReferencedObject {
1856                        __ptr,
1857                        parent,
1858                        ..Default::default()
1859                    };
1860                    let parent = hkbBindable {
1861                        __ptr,
1862                        parent,
1863                        m_variableBindingSet,
1864                        ..Default::default()
1865                    };
1866                    let parent = hkbNode {
1867                        __ptr,
1868                        parent,
1869                        m_userData,
1870                        m_name,
1871                        ..Default::default()
1872                    };
1873                    let parent = hkbModifier {
1874                        __ptr,
1875                        parent,
1876                        m_enable,
1877                        ..Default::default()
1878                    };
1879                    let __ptr = __A::class_ptr(&mut __map);
1880                    _serde::__private::Ok(hkbLookAtModifier {
1881                        __ptr,
1882                        parent,
1883                        m_targetWS,
1884                        m_headForwardLS,
1885                        m_neckForwardLS,
1886                        m_neckRightLS,
1887                        m_eyePositionHS,
1888                        m_newTargetGain,
1889                        m_onGain,
1890                        m_offGain,
1891                        m_limitAngleDegrees,
1892                        m_limitAngleLeft,
1893                        m_limitAngleRight,
1894                        m_limitAngleUp,
1895                        m_limitAngleDown,
1896                        m_headIndex,
1897                        m_neckIndex,
1898                        m_isOn,
1899                        m_individualLimitsOn,
1900                        m_isTargetInsideLimitCone,
1901                        ..Default::default()
1902                    })
1903                }
1904            }
1905            const FIELDS: &[&str] = &[
1906                "targetWS",
1907                "headForwardLS",
1908                "neckForwardLS",
1909                "neckRightLS",
1910                "eyePositionHS",
1911                "newTargetGain",
1912                "onGain",
1913                "offGain",
1914                "limitAngleDegrees",
1915                "limitAngleLeft",
1916                "limitAngleRight",
1917                "limitAngleUp",
1918                "limitAngleDown",
1919                "headIndex",
1920                "neckIndex",
1921                "isOn",
1922                "individualLimitsOn",
1923                "isTargetInsideLimitCone",
1924                "lookAtLastTargetWS",
1925                "lookAtWeight",
1926            ];
1927            _serde::Deserializer::deserialize_struct(
1928                deserializer,
1929                "hkbLookAtModifier",
1930                FIELDS,
1931                __hkbLookAtModifierVisitor {
1932                    marker: _serde::__private::PhantomData::<hkbLookAtModifier>,
1933                    lifetime: _serde::__private::PhantomData,
1934                },
1935            )
1936        }
1937    }
1938};