havok_classes/generated/
hkpVehicleDefaultEngine_.rs

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