havok_classes/generated/
hkpVehicleDefaultTransmission_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpVehicleDefaultTransmission`
5/// - version: `0`
6/// - signature: `0x235d5d6b`
7/// - size: ` 52`(x86)/` 72`(x86_64)
8/// -  vtable: `true`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkpVehicleDefaultTransmission {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkpVehicleTransmission,
30    /// # C++ Info
31    /// - name: `downshiftRPM`(ctype: `hkReal`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  4`(x86)/`  4`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "downshiftRPM"))]
35    #[cfg_attr(feature = "serde", serde(rename = "downshiftRPM"))]
36    pub m_downshiftRPM: f32,
37    /// # C++ Info
38    /// - name: `upshiftRPM`(ctype: `hkReal`)
39    /// - offset: ` 12`(x86)/` 20`(x86_64)
40    /// - type_size: `  4`(x86)/`  4`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "upshiftRPM"))]
42    #[cfg_attr(feature = "serde", serde(rename = "upshiftRPM"))]
43    pub m_upshiftRPM: f32,
44    /// # C++ Info
45    /// - name: `primaryTransmissionRatio`(ctype: `hkReal`)
46    /// - offset: ` 16`(x86)/` 24`(x86_64)
47    /// - type_size: `  4`(x86)/`  4`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "primaryTransmissionRatio"))]
49    #[cfg_attr(feature = "serde", serde(rename = "primaryTransmissionRatio"))]
50    pub m_primaryTransmissionRatio: f32,
51    /// # C++ Info
52    /// - name: `clutchDelayTime`(ctype: `hkReal`)
53    /// - offset: ` 20`(x86)/` 28`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "clutchDelayTime"))]
56    #[cfg_attr(feature = "serde", serde(rename = "clutchDelayTime"))]
57    pub m_clutchDelayTime: f32,
58    /// # C++ Info
59    /// - name: `reverseGearRatio`(ctype: `hkReal`)
60    /// - offset: ` 24`(x86)/` 32`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "reverseGearRatio"))]
63    #[cfg_attr(feature = "serde", serde(rename = "reverseGearRatio"))]
64    pub m_reverseGearRatio: f32,
65    /// # C++ Info
66    /// - name: `gearsRatio`(ctype: `hkArray<hkReal>`)
67    /// - offset: ` 28`(x86)/` 40`(x86_64)
68    /// - type_size: ` 12`(x86)/` 16`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "gearsRatio"))]
70    #[cfg_attr(feature = "serde", serde(rename = "gearsRatio"))]
71    pub m_gearsRatio: Vec<f32>,
72    /// # C++ Info
73    /// - name: `wheelsTorqueRatio`(ctype: `hkArray<hkReal>`)
74    /// - offset: ` 40`(x86)/` 56`(x86_64)
75    /// - type_size: ` 12`(x86)/` 16`(x86_64)
76    #[cfg_attr(feature = "json_schema", schemars(rename = "wheelsTorqueRatio"))]
77    #[cfg_attr(feature = "serde", serde(rename = "wheelsTorqueRatio"))]
78    pub m_wheelsTorqueRatio: Vec<f32>,
79}
80const _: () = {
81    use havok_serde as _serde;
82    impl _serde::HavokClass for hkpVehicleDefaultTransmission {
83        #[inline]
84        fn name(&self) -> &'static str {
85            "hkpVehicleDefaultTransmission"
86        }
87        #[inline]
88        fn signature(&self) -> _serde::__private::Signature {
89            _serde::__private::Signature::new(0x235d5d6b)
90        }
91        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
92        fn deps_indexes(&self) -> Vec<usize> {
93            let mut v = Vec::new();
94            v
95        }
96    }
97    impl _serde::Serialize for hkpVehicleDefaultTransmission {
98        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
99        where
100            S: _serde::ser::Serializer,
101        {
102            let class_meta = self
103                .__ptr
104                .map(|name| (name, _serde::__private::Signature::new(0x235d5d6b)));
105            let mut serializer = __serializer
106                .serialize_struct(
107                    "hkpVehicleDefaultTransmission",
108                    class_meta,
109                    (52u64, 72u64),
110                )?;
111            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
112            serializer
113                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
114            serializer
115                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
116            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
117            serializer.serialize_field("downshiftRPM", &self.m_downshiftRPM)?;
118            serializer.serialize_field("upshiftRPM", &self.m_upshiftRPM)?;
119            serializer
120                .serialize_field(
121                    "primaryTransmissionRatio",
122                    &self.m_primaryTransmissionRatio,
123                )?;
124            serializer.serialize_field("clutchDelayTime", &self.m_clutchDelayTime)?;
125            serializer.serialize_field("reverseGearRatio", &self.m_reverseGearRatio)?;
126            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
127            serializer
128                .serialize_array_field(
129                    "gearsRatio",
130                    &self.m_gearsRatio,
131                    TypeSize::NonPtr,
132                )?;
133            serializer
134                .serialize_array_field(
135                    "wheelsTorqueRatio",
136                    &self.m_wheelsTorqueRatio,
137                    TypeSize::NonPtr,
138                )?;
139            serializer.end()
140        }
141    }
142};
143#[doc(hidden)]
144#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
145const _: () = {
146    use havok_serde as _serde;
147    #[automatically_derived]
148    impl<'de> _serde::Deserialize<'de> for hkpVehicleDefaultTransmission {
149        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
150        where
151            __D: _serde::Deserializer<'de>,
152        {
153            #[allow(non_camel_case_types)]
154            enum __Field {
155                m_downshiftRPM,
156                m_upshiftRPM,
157                m_primaryTransmissionRatio,
158                m_clutchDelayTime,
159                m_reverseGearRatio,
160                m_gearsRatio,
161                m_wheelsTorqueRatio,
162                __ignore,
163            }
164            struct __FieldVisitor;
165            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
166                type Value = __Field;
167                fn expecting(
168                    &self,
169                    __formatter: &mut core::fmt::Formatter,
170                ) -> core::fmt::Result {
171                    core::fmt::Formatter::write_str(__formatter, "field identifier")
172                }
173                /// Intended for use in XML.
174                #[allow(clippy::match_single_binding)]
175                #[allow(clippy::reversed_empty_ranges)]
176                #[allow(clippy::single_match)]
177                fn visit_key<__E>(
178                    self,
179                    __value: &str,
180                ) -> core::result::Result<Self::Value, __E>
181                where
182                    __E: _serde::de::Error,
183                {
184                    match __value {
185                        "downshiftRPM" => Ok(__Field::m_downshiftRPM),
186                        "upshiftRPM" => Ok(__Field::m_upshiftRPM),
187                        "primaryTransmissionRatio" => {
188                            Ok(__Field::m_primaryTransmissionRatio)
189                        }
190                        "clutchDelayTime" => Ok(__Field::m_clutchDelayTime),
191                        "reverseGearRatio" => Ok(__Field::m_reverseGearRatio),
192                        "gearsRatio" => Ok(__Field::m_gearsRatio),
193                        "wheelsTorqueRatio" => Ok(__Field::m_wheelsTorqueRatio),
194                        _ => Ok(__Field::__ignore),
195                    }
196                }
197            }
198            impl<'de> _serde::Deserialize<'de> for __Field {
199                #[inline]
200                fn deserialize<__D>(
201                    __deserializer: __D,
202                ) -> core::result::Result<Self, __D::Error>
203                where
204                    __D: _serde::Deserializer<'de>,
205                {
206                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
207                }
208            }
209            struct __hkpVehicleDefaultTransmissionVisitor<'de> {
210                marker: _serde::__private::PhantomData<hkpVehicleDefaultTransmission>,
211                lifetime: _serde::__private::PhantomData<&'de ()>,
212            }
213            #[allow(clippy::match_single_binding)]
214            #[allow(clippy::reversed_empty_ranges)]
215            #[allow(clippy::single_match)]
216            impl<'de> _serde::de::Visitor<'de>
217            for __hkpVehicleDefaultTransmissionVisitor<'de> {
218                type Value = hkpVehicleDefaultTransmission;
219                fn expecting(
220                    &self,
221                    __formatter: &mut core::fmt::Formatter,
222                ) -> core::fmt::Result {
223                    core::fmt::Formatter::write_str(
224                        __formatter,
225                        "struct hkpVehicleDefaultTransmission",
226                    )
227                }
228                fn visit_struct_for_bytes<__A>(
229                    self,
230                    mut __map: __A,
231                ) -> _serde::__private::Result<Self::Value, __A::Error>
232                where
233                    __A: _serde::de::MapAccess<'de>,
234                {
235                    let __ptr = __A::class_ptr(&mut __map);
236                    let parent = __A::parent_value(&mut __map)?;
237                    let mut m_downshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
238                    let mut m_upshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
239                    let mut m_primaryTransmissionRatio: _serde::__private::Option<f32> = _serde::__private::None;
240                    let mut m_clutchDelayTime: _serde::__private::Option<f32> = _serde::__private::None;
241                    let mut m_reverseGearRatio: _serde::__private::Option<f32> = _serde::__private::None;
242                    let mut m_gearsRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
243                    let mut m_wheelsTorqueRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
244                    for i in 0..7usize {
245                        match i {
246                            0usize => {
247                                if _serde::__private::Option::is_some(&m_downshiftRPM) {
248                                    return _serde::__private::Err(
249                                        <__A::Error as _serde::de::Error>::duplicate_field(
250                                            "downshiftRPM",
251                                        ),
252                                    );
253                                }
254                                m_downshiftRPM = _serde::__private::Some(
255                                    match __A::next_value::<f32>(&mut __map) {
256                                        _serde::__private::Ok(__val) => __val,
257                                        _serde::__private::Err(__err) => {
258                                            return _serde::__private::Err(__err);
259                                        }
260                                    },
261                                );
262                            }
263                            1usize => {
264                                if _serde::__private::Option::is_some(&m_upshiftRPM) {
265                                    return _serde::__private::Err(
266                                        <__A::Error as _serde::de::Error>::duplicate_field(
267                                            "upshiftRPM",
268                                        ),
269                                    );
270                                }
271                                m_upshiftRPM = _serde::__private::Some(
272                                    match __A::next_value::<f32>(&mut __map) {
273                                        _serde::__private::Ok(__val) => __val,
274                                        _serde::__private::Err(__err) => {
275                                            return _serde::__private::Err(__err);
276                                        }
277                                    },
278                                );
279                            }
280                            2usize => {
281                                if _serde::__private::Option::is_some(
282                                    &m_primaryTransmissionRatio,
283                                ) {
284                                    return _serde::__private::Err(
285                                        <__A::Error as _serde::de::Error>::duplicate_field(
286                                            "primaryTransmissionRatio",
287                                        ),
288                                    );
289                                }
290                                m_primaryTransmissionRatio = _serde::__private::Some(
291                                    match __A::next_value::<f32>(&mut __map) {
292                                        _serde::__private::Ok(__val) => __val,
293                                        _serde::__private::Err(__err) => {
294                                            return _serde::__private::Err(__err);
295                                        }
296                                    },
297                                );
298                            }
299                            3usize => {
300                                if _serde::__private::Option::is_some(&m_clutchDelayTime) {
301                                    return _serde::__private::Err(
302                                        <__A::Error as _serde::de::Error>::duplicate_field(
303                                            "clutchDelayTime",
304                                        ),
305                                    );
306                                }
307                                m_clutchDelayTime = _serde::__private::Some(
308                                    match __A::next_value::<f32>(&mut __map) {
309                                        _serde::__private::Ok(__val) => __val,
310                                        _serde::__private::Err(__err) => {
311                                            return _serde::__private::Err(__err);
312                                        }
313                                    },
314                                );
315                            }
316                            4usize => {
317                                if _serde::__private::Option::is_some(&m_reverseGearRatio) {
318                                    return _serde::__private::Err(
319                                        <__A::Error as _serde::de::Error>::duplicate_field(
320                                            "reverseGearRatio",
321                                        ),
322                                    );
323                                }
324                                m_reverseGearRatio = _serde::__private::Some(
325                                    match __A::next_value::<f32>(&mut __map) {
326                                        _serde::__private::Ok(__val) => __val,
327                                        _serde::__private::Err(__err) => {
328                                            return _serde::__private::Err(__err);
329                                        }
330                                    },
331                                );
332                            }
333                            5usize => {
334                                if _serde::__private::Option::is_some(&m_gearsRatio) {
335                                    return _serde::__private::Err(
336                                        <__A::Error as _serde::de::Error>::duplicate_field(
337                                            "gearsRatio",
338                                        ),
339                                    );
340                                }
341                                __A::pad(&mut __map, 0usize, 4usize)?;
342                                m_gearsRatio = _serde::__private::Some(
343                                    match __A::next_value::<Vec<f32>>(&mut __map) {
344                                        _serde::__private::Ok(__val) => __val,
345                                        _serde::__private::Err(__err) => {
346                                            return _serde::__private::Err(__err);
347                                        }
348                                    },
349                                );
350                            }
351                            6usize => {
352                                if _serde::__private::Option::is_some(
353                                    &m_wheelsTorqueRatio,
354                                ) {
355                                    return _serde::__private::Err(
356                                        <__A::Error as _serde::de::Error>::duplicate_field(
357                                            "wheelsTorqueRatio",
358                                        ),
359                                    );
360                                }
361                                m_wheelsTorqueRatio = _serde::__private::Some(
362                                    match __A::next_value::<Vec<f32>>(&mut __map) {
363                                        _serde::__private::Ok(__val) => __val,
364                                        _serde::__private::Err(__err) => {
365                                            return _serde::__private::Err(__err);
366                                        }
367                                    },
368                                );
369                            }
370                            _ => {}
371                        }
372                    }
373                    let m_downshiftRPM = match m_downshiftRPM {
374                        _serde::__private::Some(__field) => __field,
375                        _serde::__private::None => {
376                            return _serde::__private::Err(
377                                <__A::Error as _serde::de::Error>::missing_field(
378                                    "downshiftRPM",
379                                ),
380                            );
381                        }
382                    };
383                    let m_upshiftRPM = match m_upshiftRPM {
384                        _serde::__private::Some(__field) => __field,
385                        _serde::__private::None => {
386                            return _serde::__private::Err(
387                                <__A::Error as _serde::de::Error>::missing_field(
388                                    "upshiftRPM",
389                                ),
390                            );
391                        }
392                    };
393                    let m_primaryTransmissionRatio = match m_primaryTransmissionRatio {
394                        _serde::__private::Some(__field) => __field,
395                        _serde::__private::None => {
396                            return _serde::__private::Err(
397                                <__A::Error as _serde::de::Error>::missing_field(
398                                    "primaryTransmissionRatio",
399                                ),
400                            );
401                        }
402                    };
403                    let m_clutchDelayTime = match m_clutchDelayTime {
404                        _serde::__private::Some(__field) => __field,
405                        _serde::__private::None => {
406                            return _serde::__private::Err(
407                                <__A::Error as _serde::de::Error>::missing_field(
408                                    "clutchDelayTime",
409                                ),
410                            );
411                        }
412                    };
413                    let m_reverseGearRatio = match m_reverseGearRatio {
414                        _serde::__private::Some(__field) => __field,
415                        _serde::__private::None => {
416                            return _serde::__private::Err(
417                                <__A::Error as _serde::de::Error>::missing_field(
418                                    "reverseGearRatio",
419                                ),
420                            );
421                        }
422                    };
423                    let m_gearsRatio = match m_gearsRatio {
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                                    "gearsRatio",
429                                ),
430                            );
431                        }
432                    };
433                    let m_wheelsTorqueRatio = match m_wheelsTorqueRatio {
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                                    "wheelsTorqueRatio",
439                                ),
440                            );
441                        }
442                    };
443                    _serde::__private::Ok(hkpVehicleDefaultTransmission {
444                        __ptr,
445                        parent,
446                        m_downshiftRPM,
447                        m_upshiftRPM,
448                        m_primaryTransmissionRatio,
449                        m_clutchDelayTime,
450                        m_reverseGearRatio,
451                        m_gearsRatio,
452                        m_wheelsTorqueRatio,
453                    })
454                }
455                #[allow(clippy::manual_unwrap_or_default)]
456                fn visit_struct<__A>(
457                    self,
458                    mut __map: __A,
459                ) -> _serde::__private::Result<Self::Value, __A::Error>
460                where
461                    __A: _serde::de::MapAccess<'de>,
462                {
463                    let mut m_downshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
464                    let mut m_upshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
465                    let mut m_primaryTransmissionRatio: _serde::__private::Option<f32> = _serde::__private::None;
466                    let mut m_clutchDelayTime: _serde::__private::Option<f32> = _serde::__private::None;
467                    let mut m_reverseGearRatio: _serde::__private::Option<f32> = _serde::__private::None;
468                    let mut m_gearsRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
469                    let mut m_wheelsTorqueRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
470                    while let _serde::__private::Some(__key) = {
471                        __A::next_key::<__Field>(&mut __map)?
472                    } {
473                        match __key {
474                            __Field::m_downshiftRPM => {
475                                #[cfg(
476                                    any(feature = "strict", feature = "ignore_duplicates")
477                                )]
478                                if _serde::__private::Option::is_some(&m_downshiftRPM) {
479                                    #[cfg(feature = "ignore_duplicates")]
480                                    {
481                                        __A::skip_value(&mut __map)?;
482                                        continue;
483                                    }
484                                    #[cfg(feature = "strict")]
485                                    return _serde::__private::Err(
486                                        <__A::Error as _serde::de::Error>::duplicate_field(
487                                            "downshiftRPM",
488                                        ),
489                                    );
490                                }
491                                m_downshiftRPM = _serde::__private::Some(
492                                    match __A::next_value::<f32>(&mut __map) {
493                                        _serde::__private::Ok(__val) => __val,
494                                        _serde::__private::Err(__err) => {
495                                            return _serde::__private::Err(__err);
496                                        }
497                                    },
498                                );
499                            }
500                            __Field::m_upshiftRPM => {
501                                #[cfg(
502                                    any(feature = "strict", feature = "ignore_duplicates")
503                                )]
504                                if _serde::__private::Option::is_some(&m_upshiftRPM) {
505                                    #[cfg(feature = "ignore_duplicates")]
506                                    {
507                                        __A::skip_value(&mut __map)?;
508                                        continue;
509                                    }
510                                    #[cfg(feature = "strict")]
511                                    return _serde::__private::Err(
512                                        <__A::Error as _serde::de::Error>::duplicate_field(
513                                            "upshiftRPM",
514                                        ),
515                                    );
516                                }
517                                m_upshiftRPM = _serde::__private::Some(
518                                    match __A::next_value::<f32>(&mut __map) {
519                                        _serde::__private::Ok(__val) => __val,
520                                        _serde::__private::Err(__err) => {
521                                            return _serde::__private::Err(__err);
522                                        }
523                                    },
524                                );
525                            }
526                            __Field::m_primaryTransmissionRatio => {
527                                #[cfg(
528                                    any(feature = "strict", feature = "ignore_duplicates")
529                                )]
530                                if _serde::__private::Option::is_some(
531                                    &m_primaryTransmissionRatio,
532                                ) {
533                                    #[cfg(feature = "ignore_duplicates")]
534                                    {
535                                        __A::skip_value(&mut __map)?;
536                                        continue;
537                                    }
538                                    #[cfg(feature = "strict")]
539                                    return _serde::__private::Err(
540                                        <__A::Error as _serde::de::Error>::duplicate_field(
541                                            "primaryTransmissionRatio",
542                                        ),
543                                    );
544                                }
545                                m_primaryTransmissionRatio = _serde::__private::Some(
546                                    match __A::next_value::<f32>(&mut __map) {
547                                        _serde::__private::Ok(__val) => __val,
548                                        _serde::__private::Err(__err) => {
549                                            return _serde::__private::Err(__err);
550                                        }
551                                    },
552                                );
553                            }
554                            __Field::m_clutchDelayTime => {
555                                #[cfg(
556                                    any(feature = "strict", feature = "ignore_duplicates")
557                                )]
558                                if _serde::__private::Option::is_some(&m_clutchDelayTime) {
559                                    #[cfg(feature = "ignore_duplicates")]
560                                    {
561                                        __A::skip_value(&mut __map)?;
562                                        continue;
563                                    }
564                                    #[cfg(feature = "strict")]
565                                    return _serde::__private::Err(
566                                        <__A::Error as _serde::de::Error>::duplicate_field(
567                                            "clutchDelayTime",
568                                        ),
569                                    );
570                                }
571                                m_clutchDelayTime = _serde::__private::Some(
572                                    match __A::next_value::<f32>(&mut __map) {
573                                        _serde::__private::Ok(__val) => __val,
574                                        _serde::__private::Err(__err) => {
575                                            return _serde::__private::Err(__err);
576                                        }
577                                    },
578                                );
579                            }
580                            __Field::m_reverseGearRatio => {
581                                #[cfg(
582                                    any(feature = "strict", feature = "ignore_duplicates")
583                                )]
584                                if _serde::__private::Option::is_some(&m_reverseGearRatio) {
585                                    #[cfg(feature = "ignore_duplicates")]
586                                    {
587                                        __A::skip_value(&mut __map)?;
588                                        continue;
589                                    }
590                                    #[cfg(feature = "strict")]
591                                    return _serde::__private::Err(
592                                        <__A::Error as _serde::de::Error>::duplicate_field(
593                                            "reverseGearRatio",
594                                        ),
595                                    );
596                                }
597                                m_reverseGearRatio = _serde::__private::Some(
598                                    match __A::next_value::<f32>(&mut __map) {
599                                        _serde::__private::Ok(__val) => __val,
600                                        _serde::__private::Err(__err) => {
601                                            return _serde::__private::Err(__err);
602                                        }
603                                    },
604                                );
605                            }
606                            __Field::m_gearsRatio => {
607                                #[cfg(
608                                    any(feature = "strict", feature = "ignore_duplicates")
609                                )]
610                                if _serde::__private::Option::is_some(&m_gearsRatio) {
611                                    #[cfg(feature = "ignore_duplicates")]
612                                    {
613                                        __A::skip_value(&mut __map)?;
614                                        continue;
615                                    }
616                                    #[cfg(feature = "strict")]
617                                    return _serde::__private::Err(
618                                        <__A::Error as _serde::de::Error>::duplicate_field(
619                                            "gearsRatio",
620                                        ),
621                                    );
622                                }
623                                m_gearsRatio = _serde::__private::Some(
624                                    match __A::next_value::<Vec<f32>>(&mut __map) {
625                                        _serde::__private::Ok(__val) => __val,
626                                        _serde::__private::Err(__err) => {
627                                            return _serde::__private::Err(__err);
628                                        }
629                                    },
630                                );
631                            }
632                            __Field::m_wheelsTorqueRatio => {
633                                #[cfg(
634                                    any(feature = "strict", feature = "ignore_duplicates")
635                                )]
636                                if _serde::__private::Option::is_some(
637                                    &m_wheelsTorqueRatio,
638                                ) {
639                                    #[cfg(feature = "ignore_duplicates")]
640                                    {
641                                        __A::skip_value(&mut __map)?;
642                                        continue;
643                                    }
644                                    #[cfg(feature = "strict")]
645                                    return _serde::__private::Err(
646                                        <__A::Error as _serde::de::Error>::duplicate_field(
647                                            "wheelsTorqueRatio",
648                                        ),
649                                    );
650                                }
651                                m_wheelsTorqueRatio = _serde::__private::Some(
652                                    match __A::next_value::<Vec<f32>>(&mut __map) {
653                                        _serde::__private::Ok(__val) => __val,
654                                        _serde::__private::Err(__err) => {
655                                            return _serde::__private::Err(__err);
656                                        }
657                                    },
658                                );
659                            }
660                            _ => __A::skip_value(&mut __map)?,
661                        }
662                    }
663                    let m_downshiftRPM = match m_downshiftRPM {
664                        _serde::__private::Some(__field) => __field,
665                        _serde::__private::None => {
666                            #[cfg(feature = "strict")]
667                            return _serde::__private::Err(
668                                <__A::Error as _serde::de::Error>::missing_field(
669                                    "downshiftRPM",
670                                ),
671                            );
672                            #[cfg(not(feature = "strict"))] Default::default()
673                        }
674                    };
675                    let m_upshiftRPM = match m_upshiftRPM {
676                        _serde::__private::Some(__field) => __field,
677                        _serde::__private::None => {
678                            #[cfg(feature = "strict")]
679                            return _serde::__private::Err(
680                                <__A::Error as _serde::de::Error>::missing_field(
681                                    "upshiftRPM",
682                                ),
683                            );
684                            #[cfg(not(feature = "strict"))] Default::default()
685                        }
686                    };
687                    let m_primaryTransmissionRatio = match m_primaryTransmissionRatio {
688                        _serde::__private::Some(__field) => __field,
689                        _serde::__private::None => {
690                            #[cfg(feature = "strict")]
691                            return _serde::__private::Err(
692                                <__A::Error as _serde::de::Error>::missing_field(
693                                    "primaryTransmissionRatio",
694                                ),
695                            );
696                            #[cfg(not(feature = "strict"))] Default::default()
697                        }
698                    };
699                    let m_clutchDelayTime = match m_clutchDelayTime {
700                        _serde::__private::Some(__field) => __field,
701                        _serde::__private::None => {
702                            #[cfg(feature = "strict")]
703                            return _serde::__private::Err(
704                                <__A::Error as _serde::de::Error>::missing_field(
705                                    "clutchDelayTime",
706                                ),
707                            );
708                            #[cfg(not(feature = "strict"))] Default::default()
709                        }
710                    };
711                    let m_reverseGearRatio = match m_reverseGearRatio {
712                        _serde::__private::Some(__field) => __field,
713                        _serde::__private::None => {
714                            #[cfg(feature = "strict")]
715                            return _serde::__private::Err(
716                                <__A::Error as _serde::de::Error>::missing_field(
717                                    "reverseGearRatio",
718                                ),
719                            );
720                            #[cfg(not(feature = "strict"))] Default::default()
721                        }
722                    };
723                    let m_gearsRatio = match m_gearsRatio {
724                        _serde::__private::Some(__field) => __field,
725                        _serde::__private::None => {
726                            #[cfg(feature = "strict")]
727                            return _serde::__private::Err(
728                                <__A::Error as _serde::de::Error>::missing_field(
729                                    "gearsRatio",
730                                ),
731                            );
732                            #[cfg(not(feature = "strict"))] Default::default()
733                        }
734                    };
735                    let m_wheelsTorqueRatio = match m_wheelsTorqueRatio {
736                        _serde::__private::Some(__field) => __field,
737                        _serde::__private::None => {
738                            #[cfg(feature = "strict")]
739                            return _serde::__private::Err(
740                                <__A::Error as _serde::de::Error>::missing_field(
741                                    "wheelsTorqueRatio",
742                                ),
743                            );
744                            #[cfg(not(feature = "strict"))] Default::default()
745                        }
746                    };
747                    let __ptr = None;
748                    let parent = hkBaseObject { __ptr };
749                    let parent = hkReferencedObject {
750                        __ptr,
751                        parent,
752                        ..Default::default()
753                    };
754                    let parent = hkpVehicleTransmission {
755                        __ptr,
756                        parent,
757                    };
758                    let __ptr = __A::class_ptr(&mut __map);
759                    _serde::__private::Ok(hkpVehicleDefaultTransmission {
760                        __ptr,
761                        parent,
762                        m_downshiftRPM,
763                        m_upshiftRPM,
764                        m_primaryTransmissionRatio,
765                        m_clutchDelayTime,
766                        m_reverseGearRatio,
767                        m_gearsRatio,
768                        m_wheelsTorqueRatio,
769                    })
770                }
771            }
772            const FIELDS: &[&str] = &[
773                "downshiftRPM",
774                "upshiftRPM",
775                "primaryTransmissionRatio",
776                "clutchDelayTime",
777                "reverseGearRatio",
778                "gearsRatio",
779                "wheelsTorqueRatio",
780            ];
781            _serde::Deserializer::deserialize_struct(
782                deserializer,
783                "hkpVehicleDefaultTransmission",
784                FIELDS,
785                __hkpVehicleDefaultTransmissionVisitor {
786                    marker: _serde::__private::PhantomData::<
787                        hkpVehicleDefaultTransmission,
788                    >,
789                    lifetime: _serde::__private::PhantomData,
790                },
791            )
792        }
793    }
794};