havok_classes/generated/
hkpGravityGun_.rs

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