havok_classes/generated/
BSLimbIKModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `BSLimbIKModifier`
5/// - version: `0`
6/// - signature: `0x8ea971e5`
7/// - size: ` 76`(x86)/`120`(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 BSLimbIKModifier<'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: `limitAngleDegrees`(ctype: `hkReal`)
33    /// - offset: ` 44`(x86)/` 80`(x86_64)
34    /// - type_size: `  4`(x86)/`  4`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleDegrees"))]
36    #[cfg_attr(feature = "serde", serde(rename = "limitAngleDegrees"))]
37    pub m_limitAngleDegrees: f32,
38    /// # C++ Info
39    /// - name: `currentAngle`(ctype: `hkReal`)
40    /// - offset: ` 48`(x86)/` 84`(x86_64)
41    /// - type_size: `  4`(x86)/`  4`(x86_64)
42    /// - flags: `SERIALIZE_IGNORED`
43    #[cfg_attr(feature = "json_schema", schemars(rename = "currentAngle"))]
44    #[cfg_attr(feature = "serde", serde(rename = "currentAngle"))]
45    pub m_currentAngle: f32,
46    /// # C++ Info
47    /// - name: `startBoneIndex`(ctype: `hkInt16`)
48    /// - offset: ` 52`(x86)/` 88`(x86_64)
49    /// - type_size: `  2`(x86)/`  2`(x86_64)
50    #[cfg_attr(feature = "json_schema", schemars(rename = "startBoneIndex"))]
51    #[cfg_attr(feature = "serde", serde(rename = "startBoneIndex"))]
52    pub m_startBoneIndex: i16,
53    /// # C++ Info
54    /// - name: `endBoneIndex`(ctype: `hkInt16`)
55    /// - offset: ` 54`(x86)/` 90`(x86_64)
56    /// - type_size: `  2`(x86)/`  2`(x86_64)
57    #[cfg_attr(feature = "json_schema", schemars(rename = "endBoneIndex"))]
58    #[cfg_attr(feature = "serde", serde(rename = "endBoneIndex"))]
59    pub m_endBoneIndex: i16,
60    /// # C++ Info
61    /// - name: `gain`(ctype: `hkReal`)
62    /// - offset: ` 56`(x86)/` 92`(x86_64)
63    /// - type_size: `  4`(x86)/`  4`(x86_64)
64    #[cfg_attr(feature = "json_schema", schemars(rename = "gain"))]
65    #[cfg_attr(feature = "serde", serde(rename = "gain"))]
66    pub m_gain: f32,
67    /// # C++ Info
68    /// - name: `boneRadius`(ctype: `hkReal`)
69    /// - offset: ` 60`(x86)/` 96`(x86_64)
70    /// - type_size: `  4`(x86)/`  4`(x86_64)
71    #[cfg_attr(feature = "json_schema", schemars(rename = "boneRadius"))]
72    #[cfg_attr(feature = "serde", serde(rename = "boneRadius"))]
73    pub m_boneRadius: f32,
74    /// # C++ Info
75    /// - name: `castOffset`(ctype: `hkReal`)
76    /// - offset: ` 64`(x86)/`100`(x86_64)
77    /// - type_size: `  4`(x86)/`  4`(x86_64)
78    #[cfg_attr(feature = "json_schema", schemars(rename = "castOffset"))]
79    #[cfg_attr(feature = "serde", serde(rename = "castOffset"))]
80    pub m_castOffset: f32,
81    /// # C++ Info
82    /// - name: `timeStep`(ctype: `hkReal`)
83    /// - offset: ` 68`(x86)/`104`(x86_64)
84    /// - type_size: `  4`(x86)/`  4`(x86_64)
85    /// - flags: `SERIALIZE_IGNORED`
86    #[cfg_attr(feature = "json_schema", schemars(rename = "timeStep"))]
87    #[cfg_attr(feature = "serde", serde(rename = "timeStep"))]
88    pub m_timeStep: f32,
89    /// # C++ Info
90    /// - name: `pSkeletonMemory`(ctype: `void*`)
91    /// - offset: ` 72`(x86)/`112`(x86_64)
92    /// - type_size: `  4`(x86)/`  8`(x86_64)
93    /// - flags: `SERIALIZE_IGNORED`
94    #[cfg_attr(feature = "json_schema", schemars(rename = "pSkeletonMemory"))]
95    #[cfg_attr(feature = "serde", serde(rename = "pSkeletonMemory"))]
96    pub m_pSkeletonMemory: Pointer,
97}
98const _: () = {
99    use havok_serde as _serde;
100    impl<'a> _serde::HavokClass for BSLimbIKModifier<'a> {
101        #[inline]
102        fn name(&self) -> &'static str {
103            "BSLimbIKModifier"
104        }
105        #[inline]
106        fn signature(&self) -> _serde::__private::Signature {
107            _serde::__private::Signature::new(0x8ea971e5)
108        }
109        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
110        fn deps_indexes(&self) -> Vec<usize> {
111            let mut v = Vec::new();
112            v.push(self.parent.parent.parent.m_variableBindingSet.get());
113            v.push(self.m_pSkeletonMemory.get());
114            v
115        }
116    }
117    impl<'a> _serde::Serialize for BSLimbIKModifier<'a> {
118        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
119        where
120            S: _serde::ser::Serializer,
121        {
122            let class_meta = self
123                .__ptr
124                .map(|name| (name, _serde::__private::Signature::new(0x8ea971e5)));
125            let mut serializer = __serializer
126                .serialize_struct("BSLimbIKModifier", class_meta, (76u64, 120u64))?;
127            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
128            serializer
129                .skip_field(
130                    "memSizeAndFlags",
131                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
132                )?;
133            serializer
134                .skip_field(
135                    "referenceCount",
136                    &self.parent.parent.parent.parent.m_referenceCount,
137                )?;
138            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
139            serializer
140                .serialize_field(
141                    "variableBindingSet",
142                    &self.parent.parent.parent.m_variableBindingSet,
143                )?;
144            serializer
145                .skip_array_field(
146                    "cachedBindables",
147                    &self.parent.parent.parent.m_cachedBindables,
148                    TypeSize::NonPtr,
149                )?;
150            serializer
151                .skip_field(
152                    "areBindablesCached",
153                    &self.parent.parent.parent.m_areBindablesCached,
154                )?;
155            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
156            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
157            serializer.serialize_field("name", &self.parent.parent.m_name)?;
158            serializer.skip_field("id", &self.parent.parent.m_id)?;
159            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
160            serializer
161                .skip_fixed_array_field(
162                    "padNode",
163                    self.parent.parent.m_padNode.as_slice(),
164                    TypeSize::NonPtr,
165                )?;
166            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
167            serializer.serialize_field("enable", &self.parent.m_enable)?;
168            serializer
169                .skip_fixed_array_field(
170                    "padModifier",
171                    self.parent.m_padModifier.as_slice(),
172                    TypeSize::NonPtr,
173                )?;
174            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
175            serializer.serialize_field("limitAngleDegrees", &self.m_limitAngleDegrees)?;
176            serializer.skip_field("currentAngle", &self.m_currentAngle)?;
177            serializer.serialize_field("startBoneIndex", &self.m_startBoneIndex)?;
178            serializer.serialize_field("endBoneIndex", &self.m_endBoneIndex)?;
179            serializer.serialize_field("gain", &self.m_gain)?;
180            serializer.serialize_field("boneRadius", &self.m_boneRadius)?;
181            serializer.serialize_field("castOffset", &self.m_castOffset)?;
182            serializer.skip_field("timeStep", &self.m_timeStep)?;
183            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
184            serializer.skip_field("pSkeletonMemory", &self.m_pSkeletonMemory)?;
185            serializer.end()
186        }
187    }
188};
189#[doc(hidden)]
190#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
191const _: () = {
192    use havok_serde as _serde;
193    #[automatically_derived]
194    impl<'de> _serde::Deserialize<'de> for BSLimbIKModifier<'de> {
195        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
196        where
197            __D: _serde::Deserializer<'de>,
198        {
199            #[allow(non_camel_case_types)]
200            enum __Field {
201                m_variableBindingSet,
202                m_userData,
203                m_name,
204                m_enable,
205                m_limitAngleDegrees,
206                m_startBoneIndex,
207                m_endBoneIndex,
208                m_gain,
209                m_boneRadius,
210                m_castOffset,
211                __ignore,
212            }
213            struct __FieldVisitor;
214            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
215                type Value = __Field;
216                fn expecting(
217                    &self,
218                    __formatter: &mut core::fmt::Formatter,
219                ) -> core::fmt::Result {
220                    core::fmt::Formatter::write_str(__formatter, "field identifier")
221                }
222                /// Intended for use in XML.
223                #[allow(clippy::match_single_binding)]
224                #[allow(clippy::reversed_empty_ranges)]
225                #[allow(clippy::single_match)]
226                fn visit_key<__E>(
227                    self,
228                    __value: &str,
229                ) -> core::result::Result<Self::Value, __E>
230                where
231                    __E: _serde::de::Error,
232                {
233                    match __value {
234                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
235                        "userData" => Ok(__Field::m_userData),
236                        "name" => Ok(__Field::m_name),
237                        "enable" => Ok(__Field::m_enable),
238                        "limitAngleDegrees" => Ok(__Field::m_limitAngleDegrees),
239                        "startBoneIndex" => Ok(__Field::m_startBoneIndex),
240                        "endBoneIndex" => Ok(__Field::m_endBoneIndex),
241                        "gain" => Ok(__Field::m_gain),
242                        "boneRadius" => Ok(__Field::m_boneRadius),
243                        "castOffset" => Ok(__Field::m_castOffset),
244                        _ => Ok(__Field::__ignore),
245                    }
246                }
247            }
248            impl<'de> _serde::Deserialize<'de> for __Field {
249                #[inline]
250                fn deserialize<__D>(
251                    __deserializer: __D,
252                ) -> core::result::Result<Self, __D::Error>
253                where
254                    __D: _serde::Deserializer<'de>,
255                {
256                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
257                }
258            }
259            struct __BSLimbIKModifierVisitor<'de> {
260                marker: _serde::__private::PhantomData<BSLimbIKModifier<'de>>,
261                lifetime: _serde::__private::PhantomData<&'de ()>,
262            }
263            #[allow(clippy::match_single_binding)]
264            #[allow(clippy::reversed_empty_ranges)]
265            #[allow(clippy::single_match)]
266            impl<'de> _serde::de::Visitor<'de> for __BSLimbIKModifierVisitor<'de> {
267                type Value = BSLimbIKModifier<'de>;
268                fn expecting(
269                    &self,
270                    __formatter: &mut core::fmt::Formatter,
271                ) -> core::fmt::Result {
272                    core::fmt::Formatter::write_str(
273                        __formatter,
274                        "struct BSLimbIKModifier",
275                    )
276                }
277                fn visit_struct_for_bytes<__A>(
278                    self,
279                    mut __map: __A,
280                ) -> _serde::__private::Result<Self::Value, __A::Error>
281                where
282                    __A: _serde::de::MapAccess<'de>,
283                {
284                    let __ptr = __A::class_ptr(&mut __map);
285                    let parent = __A::parent_value(&mut __map)?;
286                    let mut m_limitAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
287                    let mut m_currentAngle: _serde::__private::Option<f32> = _serde::__private::None;
288                    let mut m_startBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
289                    let mut m_endBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
290                    let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
291                    let mut m_boneRadius: _serde::__private::Option<f32> = _serde::__private::None;
292                    let mut m_castOffset: _serde::__private::Option<f32> = _serde::__private::None;
293                    let mut m_timeStep: _serde::__private::Option<f32> = _serde::__private::None;
294                    let mut m_pSkeletonMemory: _serde::__private::Option<Pointer> = _serde::__private::None;
295                    for i in 0..9usize {
296                        match i {
297                            0usize => {
298                                if _serde::__private::Option::is_some(
299                                    &m_limitAngleDegrees,
300                                ) {
301                                    return _serde::__private::Err(
302                                        <__A::Error as _serde::de::Error>::duplicate_field(
303                                            "limitAngleDegrees",
304                                        ),
305                                    );
306                                }
307                                m_limitAngleDegrees = _serde::__private::Some(
308                                    match __A::next_value::<f32>(&mut __map) {
309                                        _serde::__private::Ok(__val) => __val,
310                                        _serde::__private::Err(__err) => {
311                                            return _serde::__private::Err(__err);
312                                        }
313                                    },
314                                );
315                            }
316                            1usize => {
317                                if _serde::__private::Option::is_some(&m_currentAngle) {
318                                    return _serde::__private::Err(
319                                        <__A::Error as _serde::de::Error>::duplicate_field(
320                                            "currentAngle",
321                                        ),
322                                    );
323                                }
324                                m_currentAngle = _serde::__private::Some(
325                                    match __A::next_value::<f32>(&mut __map) {
326                                        _serde::__private::Ok(__val) => __val,
327                                        _serde::__private::Err(__err) => {
328                                            return _serde::__private::Err(__err);
329                                        }
330                                    },
331                                );
332                            }
333                            2usize => {
334                                if _serde::__private::Option::is_some(&m_startBoneIndex) {
335                                    return _serde::__private::Err(
336                                        <__A::Error as _serde::de::Error>::duplicate_field(
337                                            "startBoneIndex",
338                                        ),
339                                    );
340                                }
341                                m_startBoneIndex = _serde::__private::Some(
342                                    match __A::next_value::<i16>(&mut __map) {
343                                        _serde::__private::Ok(__val) => __val,
344                                        _serde::__private::Err(__err) => {
345                                            return _serde::__private::Err(__err);
346                                        }
347                                    },
348                                );
349                            }
350                            3usize => {
351                                if _serde::__private::Option::is_some(&m_endBoneIndex) {
352                                    return _serde::__private::Err(
353                                        <__A::Error as _serde::de::Error>::duplicate_field(
354                                            "endBoneIndex",
355                                        ),
356                                    );
357                                }
358                                m_endBoneIndex = _serde::__private::Some(
359                                    match __A::next_value::<i16>(&mut __map) {
360                                        _serde::__private::Ok(__val) => __val,
361                                        _serde::__private::Err(__err) => {
362                                            return _serde::__private::Err(__err);
363                                        }
364                                    },
365                                );
366                            }
367                            4usize => {
368                                if _serde::__private::Option::is_some(&m_gain) {
369                                    return _serde::__private::Err(
370                                        <__A::Error as _serde::de::Error>::duplicate_field("gain"),
371                                    );
372                                }
373                                m_gain = _serde::__private::Some(
374                                    match __A::next_value::<f32>(&mut __map) {
375                                        _serde::__private::Ok(__val) => __val,
376                                        _serde::__private::Err(__err) => {
377                                            return _serde::__private::Err(__err);
378                                        }
379                                    },
380                                );
381                            }
382                            5usize => {
383                                if _serde::__private::Option::is_some(&m_boneRadius) {
384                                    return _serde::__private::Err(
385                                        <__A::Error as _serde::de::Error>::duplicate_field(
386                                            "boneRadius",
387                                        ),
388                                    );
389                                }
390                                m_boneRadius = _serde::__private::Some(
391                                    match __A::next_value::<f32>(&mut __map) {
392                                        _serde::__private::Ok(__val) => __val,
393                                        _serde::__private::Err(__err) => {
394                                            return _serde::__private::Err(__err);
395                                        }
396                                    },
397                                );
398                            }
399                            6usize => {
400                                if _serde::__private::Option::is_some(&m_castOffset) {
401                                    return _serde::__private::Err(
402                                        <__A::Error as _serde::de::Error>::duplicate_field(
403                                            "castOffset",
404                                        ),
405                                    );
406                                }
407                                m_castOffset = _serde::__private::Some(
408                                    match __A::next_value::<f32>(&mut __map) {
409                                        _serde::__private::Ok(__val) => __val,
410                                        _serde::__private::Err(__err) => {
411                                            return _serde::__private::Err(__err);
412                                        }
413                                    },
414                                );
415                            }
416                            7usize => {
417                                if _serde::__private::Option::is_some(&m_timeStep) {
418                                    return _serde::__private::Err(
419                                        <__A::Error as _serde::de::Error>::duplicate_field(
420                                            "timeStep",
421                                        ),
422                                    );
423                                }
424                                m_timeStep = _serde::__private::Some(
425                                    match __A::next_value::<f32>(&mut __map) {
426                                        _serde::__private::Ok(__val) => __val,
427                                        _serde::__private::Err(__err) => {
428                                            return _serde::__private::Err(__err);
429                                        }
430                                    },
431                                );
432                            }
433                            8usize => {
434                                if _serde::__private::Option::is_some(&m_pSkeletonMemory) {
435                                    return _serde::__private::Err(
436                                        <__A::Error as _serde::de::Error>::duplicate_field(
437                                            "pSkeletonMemory",
438                                        ),
439                                    );
440                                }
441                                __A::pad(&mut __map, 0usize, 4usize)?;
442                                m_pSkeletonMemory = _serde::__private::Some(
443                                    match __A::next_value::<Pointer>(&mut __map) {
444                                        _serde::__private::Ok(__val) => __val,
445                                        _serde::__private::Err(__err) => {
446                                            return _serde::__private::Err(__err);
447                                        }
448                                    },
449                                );
450                            }
451                            _ => {}
452                        }
453                    }
454                    let m_limitAngleDegrees = match m_limitAngleDegrees {
455                        _serde::__private::Some(__field) => __field,
456                        _serde::__private::None => {
457                            return _serde::__private::Err(
458                                <__A::Error as _serde::de::Error>::missing_field(
459                                    "limitAngleDegrees",
460                                ),
461                            );
462                        }
463                    };
464                    let m_currentAngle = match m_currentAngle {
465                        _serde::__private::Some(__field) => __field,
466                        _serde::__private::None => {
467                            return _serde::__private::Err(
468                                <__A::Error as _serde::de::Error>::missing_field(
469                                    "currentAngle",
470                                ),
471                            );
472                        }
473                    };
474                    let m_startBoneIndex = match m_startBoneIndex {
475                        _serde::__private::Some(__field) => __field,
476                        _serde::__private::None => {
477                            return _serde::__private::Err(
478                                <__A::Error as _serde::de::Error>::missing_field(
479                                    "startBoneIndex",
480                                ),
481                            );
482                        }
483                    };
484                    let m_endBoneIndex = match m_endBoneIndex {
485                        _serde::__private::Some(__field) => __field,
486                        _serde::__private::None => {
487                            return _serde::__private::Err(
488                                <__A::Error as _serde::de::Error>::missing_field(
489                                    "endBoneIndex",
490                                ),
491                            );
492                        }
493                    };
494                    let m_gain = match m_gain {
495                        _serde::__private::Some(__field) => __field,
496                        _serde::__private::None => {
497                            return _serde::__private::Err(
498                                <__A::Error as _serde::de::Error>::missing_field("gain"),
499                            );
500                        }
501                    };
502                    let m_boneRadius = match m_boneRadius {
503                        _serde::__private::Some(__field) => __field,
504                        _serde::__private::None => {
505                            return _serde::__private::Err(
506                                <__A::Error as _serde::de::Error>::missing_field(
507                                    "boneRadius",
508                                ),
509                            );
510                        }
511                    };
512                    let m_castOffset = match m_castOffset {
513                        _serde::__private::Some(__field) => __field,
514                        _serde::__private::None => {
515                            return _serde::__private::Err(
516                                <__A::Error as _serde::de::Error>::missing_field(
517                                    "castOffset",
518                                ),
519                            );
520                        }
521                    };
522                    let m_timeStep = match m_timeStep {
523                        _serde::__private::Some(__field) => __field,
524                        _serde::__private::None => {
525                            return _serde::__private::Err(
526                                <__A::Error as _serde::de::Error>::missing_field("timeStep"),
527                            );
528                        }
529                    };
530                    let m_pSkeletonMemory = match m_pSkeletonMemory {
531                        _serde::__private::Some(__field) => __field,
532                        _serde::__private::None => {
533                            return _serde::__private::Err(
534                                <__A::Error as _serde::de::Error>::missing_field(
535                                    "pSkeletonMemory",
536                                ),
537                            );
538                        }
539                    };
540                    _serde::__private::Ok(BSLimbIKModifier {
541                        __ptr,
542                        parent,
543                        m_limitAngleDegrees,
544                        m_currentAngle,
545                        m_startBoneIndex,
546                        m_endBoneIndex,
547                        m_gain,
548                        m_boneRadius,
549                        m_castOffset,
550                        m_timeStep,
551                        m_pSkeletonMemory,
552                    })
553                }
554                #[allow(clippy::manual_unwrap_or_default)]
555                fn visit_struct<__A>(
556                    self,
557                    mut __map: __A,
558                ) -> _serde::__private::Result<Self::Value, __A::Error>
559                where
560                    __A: _serde::de::MapAccess<'de>,
561                {
562                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
563                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
564                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
565                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
566                    let mut m_limitAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
567                    let mut m_startBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
568                    let mut m_endBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
569                    let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
570                    let mut m_boneRadius: _serde::__private::Option<f32> = _serde::__private::None;
571                    let mut m_castOffset: _serde::__private::Option<f32> = _serde::__private::None;
572                    while let _serde::__private::Some(__key) = {
573                        __A::next_key::<__Field>(&mut __map)?
574                    } {
575                        match __key {
576                            __Field::m_variableBindingSet => {
577                                #[cfg(
578                                    any(feature = "strict", feature = "ignore_duplicates")
579                                )]
580                                if _serde::__private::Option::is_some(
581                                    &m_variableBindingSet,
582                                ) {
583                                    #[cfg(feature = "ignore_duplicates")]
584                                    {
585                                        __A::skip_value(&mut __map)?;
586                                        continue;
587                                    }
588                                    #[cfg(feature = "strict")]
589                                    return _serde::__private::Err(
590                                        <__A::Error as _serde::de::Error>::duplicate_field(
591                                            "variableBindingSet",
592                                        ),
593                                    );
594                                }
595                                m_variableBindingSet = _serde::__private::Some(
596                                    match __A::next_value::<Pointer>(&mut __map) {
597                                        _serde::__private::Ok(__val) => __val,
598                                        _serde::__private::Err(__err) => {
599                                            return _serde::__private::Err(__err);
600                                        }
601                                    },
602                                );
603                            }
604                            __Field::m_userData => {
605                                #[cfg(
606                                    any(feature = "strict", feature = "ignore_duplicates")
607                                )]
608                                if _serde::__private::Option::is_some(&m_userData) {
609                                    #[cfg(feature = "ignore_duplicates")]
610                                    {
611                                        __A::skip_value(&mut __map)?;
612                                        continue;
613                                    }
614                                    #[cfg(feature = "strict")]
615                                    return _serde::__private::Err(
616                                        <__A::Error as _serde::de::Error>::duplicate_field(
617                                            "userData",
618                                        ),
619                                    );
620                                }
621                                m_userData = _serde::__private::Some(
622                                    match __A::next_value::<Ulong>(&mut __map) {
623                                        _serde::__private::Ok(__val) => __val,
624                                        _serde::__private::Err(__err) => {
625                                            return _serde::__private::Err(__err);
626                                        }
627                                    },
628                                );
629                            }
630                            __Field::m_name => {
631                                #[cfg(
632                                    any(feature = "strict", feature = "ignore_duplicates")
633                                )]
634                                if _serde::__private::Option::is_some(&m_name) {
635                                    #[cfg(feature = "ignore_duplicates")]
636                                    {
637                                        __A::skip_value(&mut __map)?;
638                                        continue;
639                                    }
640                                    #[cfg(feature = "strict")]
641                                    return _serde::__private::Err(
642                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
643                                    );
644                                }
645                                m_name = _serde::__private::Some(
646                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
647                                        _serde::__private::Ok(__val) => __val,
648                                        _serde::__private::Err(__err) => {
649                                            return _serde::__private::Err(__err);
650                                        }
651                                    },
652                                );
653                            }
654                            __Field::m_enable => {
655                                #[cfg(
656                                    any(feature = "strict", feature = "ignore_duplicates")
657                                )]
658                                if _serde::__private::Option::is_some(&m_enable) {
659                                    #[cfg(feature = "ignore_duplicates")]
660                                    {
661                                        __A::skip_value(&mut __map)?;
662                                        continue;
663                                    }
664                                    #[cfg(feature = "strict")]
665                                    return _serde::__private::Err(
666                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
667                                    );
668                                }
669                                m_enable = _serde::__private::Some(
670                                    match __A::next_value::<bool>(&mut __map) {
671                                        _serde::__private::Ok(__val) => __val,
672                                        _serde::__private::Err(__err) => {
673                                            return _serde::__private::Err(__err);
674                                        }
675                                    },
676                                );
677                            }
678                            __Field::m_limitAngleDegrees => {
679                                #[cfg(
680                                    any(feature = "strict", feature = "ignore_duplicates")
681                                )]
682                                if _serde::__private::Option::is_some(
683                                    &m_limitAngleDegrees,
684                                ) {
685                                    #[cfg(feature = "ignore_duplicates")]
686                                    {
687                                        __A::skip_value(&mut __map)?;
688                                        continue;
689                                    }
690                                    #[cfg(feature = "strict")]
691                                    return _serde::__private::Err(
692                                        <__A::Error as _serde::de::Error>::duplicate_field(
693                                            "limitAngleDegrees",
694                                        ),
695                                    );
696                                }
697                                m_limitAngleDegrees = _serde::__private::Some(
698                                    match __A::next_value::<f32>(&mut __map) {
699                                        _serde::__private::Ok(__val) => __val,
700                                        _serde::__private::Err(__err) => {
701                                            return _serde::__private::Err(__err);
702                                        }
703                                    },
704                                );
705                            }
706                            __Field::m_startBoneIndex => {
707                                #[cfg(
708                                    any(feature = "strict", feature = "ignore_duplicates")
709                                )]
710                                if _serde::__private::Option::is_some(&m_startBoneIndex) {
711                                    #[cfg(feature = "ignore_duplicates")]
712                                    {
713                                        __A::skip_value(&mut __map)?;
714                                        continue;
715                                    }
716                                    #[cfg(feature = "strict")]
717                                    return _serde::__private::Err(
718                                        <__A::Error as _serde::de::Error>::duplicate_field(
719                                            "startBoneIndex",
720                                        ),
721                                    );
722                                }
723                                m_startBoneIndex = _serde::__private::Some(
724                                    match __A::next_value::<i16>(&mut __map) {
725                                        _serde::__private::Ok(__val) => __val,
726                                        _serde::__private::Err(__err) => {
727                                            return _serde::__private::Err(__err);
728                                        }
729                                    },
730                                );
731                            }
732                            __Field::m_endBoneIndex => {
733                                #[cfg(
734                                    any(feature = "strict", feature = "ignore_duplicates")
735                                )]
736                                if _serde::__private::Option::is_some(&m_endBoneIndex) {
737                                    #[cfg(feature = "ignore_duplicates")]
738                                    {
739                                        __A::skip_value(&mut __map)?;
740                                        continue;
741                                    }
742                                    #[cfg(feature = "strict")]
743                                    return _serde::__private::Err(
744                                        <__A::Error as _serde::de::Error>::duplicate_field(
745                                            "endBoneIndex",
746                                        ),
747                                    );
748                                }
749                                m_endBoneIndex = _serde::__private::Some(
750                                    match __A::next_value::<i16>(&mut __map) {
751                                        _serde::__private::Ok(__val) => __val,
752                                        _serde::__private::Err(__err) => {
753                                            return _serde::__private::Err(__err);
754                                        }
755                                    },
756                                );
757                            }
758                            __Field::m_gain => {
759                                #[cfg(
760                                    any(feature = "strict", feature = "ignore_duplicates")
761                                )]
762                                if _serde::__private::Option::is_some(&m_gain) {
763                                    #[cfg(feature = "ignore_duplicates")]
764                                    {
765                                        __A::skip_value(&mut __map)?;
766                                        continue;
767                                    }
768                                    #[cfg(feature = "strict")]
769                                    return _serde::__private::Err(
770                                        <__A::Error as _serde::de::Error>::duplicate_field("gain"),
771                                    );
772                                }
773                                m_gain = _serde::__private::Some(
774                                    match __A::next_value::<f32>(&mut __map) {
775                                        _serde::__private::Ok(__val) => __val,
776                                        _serde::__private::Err(__err) => {
777                                            return _serde::__private::Err(__err);
778                                        }
779                                    },
780                                );
781                            }
782                            __Field::m_boneRadius => {
783                                #[cfg(
784                                    any(feature = "strict", feature = "ignore_duplicates")
785                                )]
786                                if _serde::__private::Option::is_some(&m_boneRadius) {
787                                    #[cfg(feature = "ignore_duplicates")]
788                                    {
789                                        __A::skip_value(&mut __map)?;
790                                        continue;
791                                    }
792                                    #[cfg(feature = "strict")]
793                                    return _serde::__private::Err(
794                                        <__A::Error as _serde::de::Error>::duplicate_field(
795                                            "boneRadius",
796                                        ),
797                                    );
798                                }
799                                m_boneRadius = _serde::__private::Some(
800                                    match __A::next_value::<f32>(&mut __map) {
801                                        _serde::__private::Ok(__val) => __val,
802                                        _serde::__private::Err(__err) => {
803                                            return _serde::__private::Err(__err);
804                                        }
805                                    },
806                                );
807                            }
808                            __Field::m_castOffset => {
809                                #[cfg(
810                                    any(feature = "strict", feature = "ignore_duplicates")
811                                )]
812                                if _serde::__private::Option::is_some(&m_castOffset) {
813                                    #[cfg(feature = "ignore_duplicates")]
814                                    {
815                                        __A::skip_value(&mut __map)?;
816                                        continue;
817                                    }
818                                    #[cfg(feature = "strict")]
819                                    return _serde::__private::Err(
820                                        <__A::Error as _serde::de::Error>::duplicate_field(
821                                            "castOffset",
822                                        ),
823                                    );
824                                }
825                                m_castOffset = _serde::__private::Some(
826                                    match __A::next_value::<f32>(&mut __map) {
827                                        _serde::__private::Ok(__val) => __val,
828                                        _serde::__private::Err(__err) => {
829                                            return _serde::__private::Err(__err);
830                                        }
831                                    },
832                                );
833                            }
834                            _ => __A::skip_value(&mut __map)?,
835                        }
836                    }
837                    let m_variableBindingSet = match m_variableBindingSet {
838                        _serde::__private::Some(__field) => __field,
839                        _serde::__private::None => {
840                            #[cfg(feature = "strict")]
841                            return _serde::__private::Err(
842                                <__A::Error as _serde::de::Error>::missing_field(
843                                    "variableBindingSet",
844                                ),
845                            );
846                            #[cfg(not(feature = "strict"))] Default::default()
847                        }
848                    };
849                    let m_userData = match m_userData {
850                        _serde::__private::Some(__field) => __field,
851                        _serde::__private::None => {
852                            #[cfg(feature = "strict")]
853                            return _serde::__private::Err(
854                                <__A::Error as _serde::de::Error>::missing_field("userData"),
855                            );
856                            #[cfg(not(feature = "strict"))] Default::default()
857                        }
858                    };
859                    let m_name = match m_name {
860                        _serde::__private::Some(__field) => __field,
861                        _serde::__private::None => {
862                            #[cfg(feature = "strict")]
863                            return _serde::__private::Err(
864                                <__A::Error as _serde::de::Error>::missing_field("name"),
865                            );
866                            #[cfg(not(feature = "strict"))] Default::default()
867                        }
868                    };
869                    let m_enable = match m_enable {
870                        _serde::__private::Some(__field) => __field,
871                        _serde::__private::None => {
872                            #[cfg(feature = "strict")]
873                            return _serde::__private::Err(
874                                <__A::Error as _serde::de::Error>::missing_field("enable"),
875                            );
876                            #[cfg(not(feature = "strict"))] Default::default()
877                        }
878                    };
879                    let m_limitAngleDegrees = match m_limitAngleDegrees {
880                        _serde::__private::Some(__field) => __field,
881                        _serde::__private::None => {
882                            #[cfg(feature = "strict")]
883                            return _serde::__private::Err(
884                                <__A::Error as _serde::de::Error>::missing_field(
885                                    "limitAngleDegrees",
886                                ),
887                            );
888                            #[cfg(not(feature = "strict"))] Default::default()
889                        }
890                    };
891                    let m_startBoneIndex = match m_startBoneIndex {
892                        _serde::__private::Some(__field) => __field,
893                        _serde::__private::None => {
894                            #[cfg(feature = "strict")]
895                            return _serde::__private::Err(
896                                <__A::Error as _serde::de::Error>::missing_field(
897                                    "startBoneIndex",
898                                ),
899                            );
900                            #[cfg(not(feature = "strict"))] Default::default()
901                        }
902                    };
903                    let m_endBoneIndex = match m_endBoneIndex {
904                        _serde::__private::Some(__field) => __field,
905                        _serde::__private::None => {
906                            #[cfg(feature = "strict")]
907                            return _serde::__private::Err(
908                                <__A::Error as _serde::de::Error>::missing_field(
909                                    "endBoneIndex",
910                                ),
911                            );
912                            #[cfg(not(feature = "strict"))] Default::default()
913                        }
914                    };
915                    let m_gain = match m_gain {
916                        _serde::__private::Some(__field) => __field,
917                        _serde::__private::None => {
918                            #[cfg(feature = "strict")]
919                            return _serde::__private::Err(
920                                <__A::Error as _serde::de::Error>::missing_field("gain"),
921                            );
922                            #[cfg(not(feature = "strict"))] Default::default()
923                        }
924                    };
925                    let m_boneRadius = match m_boneRadius {
926                        _serde::__private::Some(__field) => __field,
927                        _serde::__private::None => {
928                            #[cfg(feature = "strict")]
929                            return _serde::__private::Err(
930                                <__A::Error as _serde::de::Error>::missing_field(
931                                    "boneRadius",
932                                ),
933                            );
934                            #[cfg(not(feature = "strict"))] Default::default()
935                        }
936                    };
937                    let m_castOffset = match m_castOffset {
938                        _serde::__private::Some(__field) => __field,
939                        _serde::__private::None => {
940                            #[cfg(feature = "strict")]
941                            return _serde::__private::Err(
942                                <__A::Error as _serde::de::Error>::missing_field(
943                                    "castOffset",
944                                ),
945                            );
946                            #[cfg(not(feature = "strict"))] Default::default()
947                        }
948                    };
949                    let __ptr = None;
950                    let parent = hkBaseObject { __ptr };
951                    let parent = hkReferencedObject {
952                        __ptr,
953                        parent,
954                        ..Default::default()
955                    };
956                    let parent = hkbBindable {
957                        __ptr,
958                        parent,
959                        m_variableBindingSet,
960                        ..Default::default()
961                    };
962                    let parent = hkbNode {
963                        __ptr,
964                        parent,
965                        m_userData,
966                        m_name,
967                        ..Default::default()
968                    };
969                    let parent = hkbModifier {
970                        __ptr,
971                        parent,
972                        m_enable,
973                        ..Default::default()
974                    };
975                    let __ptr = __A::class_ptr(&mut __map);
976                    _serde::__private::Ok(BSLimbIKModifier {
977                        __ptr,
978                        parent,
979                        m_limitAngleDegrees,
980                        m_startBoneIndex,
981                        m_endBoneIndex,
982                        m_gain,
983                        m_boneRadius,
984                        m_castOffset,
985                        ..Default::default()
986                    })
987                }
988            }
989            const FIELDS: &[&str] = &[
990                "limitAngleDegrees",
991                "currentAngle",
992                "startBoneIndex",
993                "endBoneIndex",
994                "gain",
995                "boneRadius",
996                "castOffset",
997                "timeStep",
998                "pSkeletonMemory",
999            ];
1000            _serde::Deserializer::deserialize_struct(
1001                deserializer,
1002                "BSLimbIKModifier",
1003                FIELDS,
1004                __BSLimbIKModifierVisitor {
1005                    marker: _serde::__private::PhantomData::<BSLimbIKModifier>,
1006                    lifetime: _serde::__private::PhantomData,
1007                },
1008            )
1009        }
1010    }
1011};