havok_classes/generated/
hkbDetectCloseToGroundModifier_.rs

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