havok_classes/generated/
hkpVehicleFrictionStatusAxisStatus_.rs

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