havok_classes/generated/
hkpVehicleInstanceWheelInfo_.rs

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