havok_classes/generated/
hkpVehicleData_.rs

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