havok_classes/generated/
hkpVehicleFrictionDescriptionAxisDescription_.rs

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