havok_classes/generated/
hkbSenseHandleModifier_.rs

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