1use super::class_requires::*;
2use super::*;
3#[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 hkpVehicleInstance<'a> {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkpUnaryAction<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
36 #[cfg_attr(feature = "serde", serde(rename = "data"))]
37 pub m_data: Pointer,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "driverInput"))]
43 #[cfg_attr(feature = "serde", serde(rename = "driverInput"))]
44 pub m_driverInput: Pointer,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "steering"))]
50 #[cfg_attr(feature = "serde", serde(rename = "steering"))]
51 pub m_steering: Pointer,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "engine"))]
57 #[cfg_attr(feature = "serde", serde(rename = "engine"))]
58 pub m_engine: Pointer,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "transmission"))]
64 #[cfg_attr(feature = "serde", serde(rename = "transmission"))]
65 pub m_transmission: Pointer,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "brake"))]
71 #[cfg_attr(feature = "serde", serde(rename = "brake"))]
72 pub m_brake: Pointer,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "suspension"))]
78 #[cfg_attr(feature = "serde", serde(rename = "suspension"))]
79 pub m_suspension: Pointer,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "aerodynamics"))]
85 #[cfg_attr(feature = "serde", serde(rename = "aerodynamics"))]
86 pub m_aerodynamics: Pointer,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "wheelCollide"))]
92 #[cfg_attr(feature = "serde", serde(rename = "wheelCollide"))]
93 pub m_wheelCollide: Pointer,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "tyreMarks"))]
99 #[cfg_attr(feature = "serde", serde(rename = "tyreMarks"))]
100 pub m_tyreMarks: Pointer,
101 #[cfg_attr(feature = "json_schema", schemars(rename = "velocityDamper"))]
106 #[cfg_attr(feature = "serde", serde(rename = "velocityDamper"))]
107 pub m_velocityDamper: Pointer,
108 #[cfg_attr(feature = "json_schema", schemars(rename = "wheelsInfo"))]
113 #[cfg_attr(feature = "serde", serde(rename = "wheelsInfo"))]
114 pub m_wheelsInfo: Vec<hkpVehicleInstanceWheelInfo>,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "frictionStatus"))]
120 #[cfg_attr(feature = "serde", serde(rename = "frictionStatus"))]
121 pub m_frictionStatus: hkpVehicleFrictionStatus,
122 #[cfg_attr(feature = "json_schema", schemars(rename = "deviceStatus"))]
127 #[cfg_attr(feature = "serde", serde(rename = "deviceStatus"))]
128 pub m_deviceStatus: Pointer,
129 #[cfg_attr(feature = "json_schema", schemars(rename = "isFixed"))]
134 #[cfg_attr(feature = "serde", serde(rename = "isFixed"))]
135 pub m_isFixed: Vec<bool>,
136 #[cfg_attr(
141 feature = "json_schema",
142 schemars(rename = "wheelsTimeSinceMaxPedalInput")
143 )]
144 #[cfg_attr(feature = "serde", serde(rename = "wheelsTimeSinceMaxPedalInput"))]
145 pub m_wheelsTimeSinceMaxPedalInput: f32,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "tryingToReverse"))]
151 #[cfg_attr(feature = "serde", serde(rename = "tryingToReverse"))]
152 pub m_tryingToReverse: bool,
153 #[cfg_attr(feature = "json_schema", schemars(rename = "torque"))]
158 #[cfg_attr(feature = "serde", serde(rename = "torque"))]
159 pub m_torque: f32,
160 #[cfg_attr(feature = "json_schema", schemars(rename = "rpm"))]
165 #[cfg_attr(feature = "serde", serde(rename = "rpm"))]
166 pub m_rpm: f32,
167 #[cfg_attr(feature = "json_schema", schemars(rename = "mainSteeringAngle"))]
172 #[cfg_attr(feature = "serde", serde(rename = "mainSteeringAngle"))]
173 pub m_mainSteeringAngle: f32,
174 #[cfg_attr(feature = "json_schema", schemars(rename = "wheelsSteeringAngle"))]
179 #[cfg_attr(feature = "serde", serde(rename = "wheelsSteeringAngle"))]
180 pub m_wheelsSteeringAngle: Vec<f32>,
181 #[cfg_attr(feature = "json_schema", schemars(rename = "isReversing"))]
186 #[cfg_attr(feature = "serde", serde(rename = "isReversing"))]
187 pub m_isReversing: bool,
188 #[cfg_attr(feature = "json_schema", schemars(rename = "currentGear"))]
193 #[cfg_attr(feature = "serde", serde(rename = "currentGear"))]
194 pub m_currentGear: i8,
195 #[cfg_attr(feature = "json_schema", schemars(rename = "delayed"))]
200 #[cfg_attr(feature = "serde", serde(rename = "delayed"))]
201 pub m_delayed: bool,
202 #[cfg_attr(feature = "json_schema", schemars(rename = "clutchDelayCountdown"))]
207 #[cfg_attr(feature = "serde", serde(rename = "clutchDelayCountdown"))]
208 pub m_clutchDelayCountdown: f32,
209}
210const _: () = {
211 use havok_serde as _serde;
212 impl<'a> _serde::HavokClass for hkpVehicleInstance<'a> {
213 #[inline]
214 fn name(&self) -> &'static str {
215 "hkpVehicleInstance"
216 }
217 #[inline]
218 fn signature(&self) -> _serde::__private::Signature {
219 _serde::__private::Signature::new(0x877bb579)
220 }
221 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
222 fn deps_indexes(&self) -> Vec<usize> {
223 let mut v = Vec::new();
224 v.push(self.parent.parent.m_world.get());
225 v.push(self.parent.parent.m_island.get());
226 v.push(self.parent.m_entity.get());
227 v.push(self.m_data.get());
228 v.push(self.m_driverInput.get());
229 v.push(self.m_steering.get());
230 v.push(self.m_engine.get());
231 v.push(self.m_transmission.get());
232 v.push(self.m_brake.get());
233 v.push(self.m_suspension.get());
234 v.push(self.m_aerodynamics.get());
235 v.push(self.m_wheelCollide.get());
236 v.push(self.m_tyreMarks.get());
237 v.push(self.m_velocityDamper.get());
238 v.extend(
239 self
240 .m_wheelsInfo
241 .iter()
242 .flat_map(|class| class.deps_indexes())
243 .collect::<Vec<usize>>(),
244 );
245 v.extend(self.m_frictionStatus.deps_indexes());
246 v.push(self.m_deviceStatus.get());
247 v
248 }
249 }
250 impl<'a> _serde::Serialize for hkpVehicleInstance<'a> {
251 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
252 where
253 S: _serde::ser::Serializer,
254 {
255 let class_meta = self
256 .__ptr
257 .map(|name| (name, _serde::__private::Signature::new(0x877bb579)));
258 let mut serializer = __serializer
259 .serialize_struct("hkpVehicleInstance", class_meta, (212u64, 304u64))?;
260 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
261 serializer
262 .skip_field(
263 "memSizeAndFlags",
264 &self.parent.parent.parent.m_memSizeAndFlags,
265 )?;
266 serializer
267 .skip_field(
268 "referenceCount",
269 &self.parent.parent.parent.m_referenceCount,
270 )?;
271 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
272 serializer.skip_field("world", &self.parent.parent.m_world)?;
273 serializer.skip_field("island", &self.parent.parent.m_island)?;
274 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
275 serializer.serialize_field("name", &self.parent.parent.m_name)?;
276 serializer.serialize_field("entity", &self.parent.m_entity)?;
277 serializer.serialize_field("data", &self.m_data)?;
278 serializer.serialize_field("driverInput", &self.m_driverInput)?;
279 serializer.serialize_field("steering", &self.m_steering)?;
280 serializer.serialize_field("engine", &self.m_engine)?;
281 serializer.serialize_field("transmission", &self.m_transmission)?;
282 serializer.serialize_field("brake", &self.m_brake)?;
283 serializer.serialize_field("suspension", &self.m_suspension)?;
284 serializer.serialize_field("aerodynamics", &self.m_aerodynamics)?;
285 serializer.serialize_field("wheelCollide", &self.m_wheelCollide)?;
286 serializer.serialize_field("tyreMarks", &self.m_tyreMarks)?;
287 serializer.serialize_field("velocityDamper", &self.m_velocityDamper)?;
288 serializer
289 .serialize_array_field(
290 "wheelsInfo",
291 &self.m_wheelsInfo,
292 TypeSize::Struct {
293 size_x86: 224u64,
294 size_x86_64: 224u64,
295 },
296 )?;
297 serializer.serialize_field("frictionStatus", &self.m_frictionStatus)?;
298 serializer.serialize_field("deviceStatus", &self.m_deviceStatus)?;
299 serializer
300 .serialize_array_field("isFixed", &self.m_isFixed, TypeSize::NonPtr)?;
301 serializer
302 .serialize_field(
303 "wheelsTimeSinceMaxPedalInput",
304 &self.m_wheelsTimeSinceMaxPedalInput,
305 )?;
306 serializer.serialize_field("tryingToReverse", &self.m_tryingToReverse)?;
307 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
308 serializer.serialize_field("torque", &self.m_torque)?;
309 serializer.serialize_field("rpm", &self.m_rpm)?;
310 serializer.serialize_field("mainSteeringAngle", &self.m_mainSteeringAngle)?;
311 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
312 serializer
313 .serialize_array_field(
314 "wheelsSteeringAngle",
315 &self.m_wheelsSteeringAngle,
316 TypeSize::NonPtr,
317 )?;
318 serializer.serialize_field("isReversing", &self.m_isReversing)?;
319 serializer.serialize_field("currentGear", &self.m_currentGear)?;
320 serializer.serialize_field("delayed", &self.m_delayed)?;
321 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
322 serializer
323 .serialize_field("clutchDelayCountdown", &self.m_clutchDelayCountdown)?;
324 serializer.end()
325 }
326 }
327};
328#[doc(hidden)]
329#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
330const _: () = {
331 use havok_serde as _serde;
332 #[automatically_derived]
333 impl<'de> _serde::Deserialize<'de> for hkpVehicleInstance<'de> {
334 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
335 where
336 __D: _serde::Deserializer<'de>,
337 {
338 #[allow(non_camel_case_types)]
339 enum __Field {
340 m_userData,
341 m_name,
342 m_entity,
343 m_data,
344 m_driverInput,
345 m_steering,
346 m_engine,
347 m_transmission,
348 m_brake,
349 m_suspension,
350 m_aerodynamics,
351 m_wheelCollide,
352 m_tyreMarks,
353 m_velocityDamper,
354 m_wheelsInfo,
355 m_frictionStatus,
356 m_deviceStatus,
357 m_isFixed,
358 m_wheelsTimeSinceMaxPedalInput,
359 m_tryingToReverse,
360 m_torque,
361 m_rpm,
362 m_mainSteeringAngle,
363 m_wheelsSteeringAngle,
364 m_isReversing,
365 m_currentGear,
366 m_delayed,
367 m_clutchDelayCountdown,
368 __ignore,
369 }
370 struct __FieldVisitor;
371 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
372 type Value = __Field;
373 fn expecting(
374 &self,
375 __formatter: &mut core::fmt::Formatter,
376 ) -> core::fmt::Result {
377 core::fmt::Formatter::write_str(__formatter, "field identifier")
378 }
379 #[allow(clippy::match_single_binding)]
381 #[allow(clippy::reversed_empty_ranges)]
382 #[allow(clippy::single_match)]
383 fn visit_key<__E>(
384 self,
385 __value: &str,
386 ) -> core::result::Result<Self::Value, __E>
387 where
388 __E: _serde::de::Error,
389 {
390 match __value {
391 "userData" => Ok(__Field::m_userData),
392 "name" => Ok(__Field::m_name),
393 "entity" => Ok(__Field::m_entity),
394 "data" => Ok(__Field::m_data),
395 "driverInput" => Ok(__Field::m_driverInput),
396 "steering" => Ok(__Field::m_steering),
397 "engine" => Ok(__Field::m_engine),
398 "transmission" => Ok(__Field::m_transmission),
399 "brake" => Ok(__Field::m_brake),
400 "suspension" => Ok(__Field::m_suspension),
401 "aerodynamics" => Ok(__Field::m_aerodynamics),
402 "wheelCollide" => Ok(__Field::m_wheelCollide),
403 "tyreMarks" => Ok(__Field::m_tyreMarks),
404 "velocityDamper" => Ok(__Field::m_velocityDamper),
405 "wheelsInfo" => Ok(__Field::m_wheelsInfo),
406 "frictionStatus" => Ok(__Field::m_frictionStatus),
407 "deviceStatus" => Ok(__Field::m_deviceStatus),
408 "isFixed" => Ok(__Field::m_isFixed),
409 "wheelsTimeSinceMaxPedalInput" => {
410 Ok(__Field::m_wheelsTimeSinceMaxPedalInput)
411 }
412 "tryingToReverse" => Ok(__Field::m_tryingToReverse),
413 "torque" => Ok(__Field::m_torque),
414 "rpm" => Ok(__Field::m_rpm),
415 "mainSteeringAngle" => Ok(__Field::m_mainSteeringAngle),
416 "wheelsSteeringAngle" => Ok(__Field::m_wheelsSteeringAngle),
417 "isReversing" => Ok(__Field::m_isReversing),
418 "currentGear" => Ok(__Field::m_currentGear),
419 "delayed" => Ok(__Field::m_delayed),
420 "clutchDelayCountdown" => Ok(__Field::m_clutchDelayCountdown),
421 _ => Ok(__Field::__ignore),
422 }
423 }
424 }
425 impl<'de> _serde::Deserialize<'de> for __Field {
426 #[inline]
427 fn deserialize<__D>(
428 __deserializer: __D,
429 ) -> core::result::Result<Self, __D::Error>
430 where
431 __D: _serde::Deserializer<'de>,
432 {
433 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
434 }
435 }
436 struct __hkpVehicleInstanceVisitor<'de> {
437 marker: _serde::__private::PhantomData<hkpVehicleInstance<'de>>,
438 lifetime: _serde::__private::PhantomData<&'de ()>,
439 }
440 #[allow(clippy::match_single_binding)]
441 #[allow(clippy::reversed_empty_ranges)]
442 #[allow(clippy::single_match)]
443 impl<'de> _serde::de::Visitor<'de> for __hkpVehicleInstanceVisitor<'de> {
444 type Value = hkpVehicleInstance<'de>;
445 fn expecting(
446 &self,
447 __formatter: &mut core::fmt::Formatter,
448 ) -> core::fmt::Result {
449 core::fmt::Formatter::write_str(
450 __formatter,
451 "struct hkpVehicleInstance",
452 )
453 }
454 fn visit_struct_for_bytes<__A>(
455 self,
456 mut __map: __A,
457 ) -> _serde::__private::Result<Self::Value, __A::Error>
458 where
459 __A: _serde::de::MapAccess<'de>,
460 {
461 let __ptr = __A::class_ptr(&mut __map);
462 let parent = __A::parent_value(&mut __map)?;
463 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
464 let mut m_driverInput: _serde::__private::Option<Pointer> = _serde::__private::None;
465 let mut m_steering: _serde::__private::Option<Pointer> = _serde::__private::None;
466 let mut m_engine: _serde::__private::Option<Pointer> = _serde::__private::None;
467 let mut m_transmission: _serde::__private::Option<Pointer> = _serde::__private::None;
468 let mut m_brake: _serde::__private::Option<Pointer> = _serde::__private::None;
469 let mut m_suspension: _serde::__private::Option<Pointer> = _serde::__private::None;
470 let mut m_aerodynamics: _serde::__private::Option<Pointer> = _serde::__private::None;
471 let mut m_wheelCollide: _serde::__private::Option<Pointer> = _serde::__private::None;
472 let mut m_tyreMarks: _serde::__private::Option<Pointer> = _serde::__private::None;
473 let mut m_velocityDamper: _serde::__private::Option<Pointer> = _serde::__private::None;
474 let mut m_wheelsInfo: _serde::__private::Option<
475 Vec<hkpVehicleInstanceWheelInfo>,
476 > = _serde::__private::None;
477 let mut m_frictionStatus: _serde::__private::Option<
478 hkpVehicleFrictionStatus,
479 > = _serde::__private::None;
480 let mut m_deviceStatus: _serde::__private::Option<Pointer> = _serde::__private::None;
481 let mut m_isFixed: _serde::__private::Option<Vec<bool>> = _serde::__private::None;
482 let mut m_wheelsTimeSinceMaxPedalInput: _serde::__private::Option<
483 f32,
484 > = _serde::__private::None;
485 let mut m_tryingToReverse: _serde::__private::Option<bool> = _serde::__private::None;
486 let mut m_torque: _serde::__private::Option<f32> = _serde::__private::None;
487 let mut m_rpm: _serde::__private::Option<f32> = _serde::__private::None;
488 let mut m_mainSteeringAngle: _serde::__private::Option<f32> = _serde::__private::None;
489 let mut m_wheelsSteeringAngle: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
490 let mut m_isReversing: _serde::__private::Option<bool> = _serde::__private::None;
491 let mut m_currentGear: _serde::__private::Option<i8> = _serde::__private::None;
492 let mut m_delayed: _serde::__private::Option<bool> = _serde::__private::None;
493 let mut m_clutchDelayCountdown: _serde::__private::Option<f32> = _serde::__private::None;
494 for i in 0..25usize {
495 match i {
496 0usize => {
497 if _serde::__private::Option::is_some(&m_data) {
498 return _serde::__private::Err(
499 <__A::Error as _serde::de::Error>::duplicate_field("data"),
500 );
501 }
502 m_data = _serde::__private::Some(
503 match __A::next_value::<Pointer>(&mut __map) {
504 _serde::__private::Ok(__val) => __val,
505 _serde::__private::Err(__err) => {
506 return _serde::__private::Err(__err);
507 }
508 },
509 );
510 }
511 1usize => {
512 if _serde::__private::Option::is_some(&m_driverInput) {
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::duplicate_field(
515 "driverInput",
516 ),
517 );
518 }
519 m_driverInput = _serde::__private::Some(
520 match __A::next_value::<Pointer>(&mut __map) {
521 _serde::__private::Ok(__val) => __val,
522 _serde::__private::Err(__err) => {
523 return _serde::__private::Err(__err);
524 }
525 },
526 );
527 }
528 2usize => {
529 if _serde::__private::Option::is_some(&m_steering) {
530 return _serde::__private::Err(
531 <__A::Error as _serde::de::Error>::duplicate_field(
532 "steering",
533 ),
534 );
535 }
536 m_steering = _serde::__private::Some(
537 match __A::next_value::<Pointer>(&mut __map) {
538 _serde::__private::Ok(__val) => __val,
539 _serde::__private::Err(__err) => {
540 return _serde::__private::Err(__err);
541 }
542 },
543 );
544 }
545 3usize => {
546 if _serde::__private::Option::is_some(&m_engine) {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::duplicate_field("engine"),
549 );
550 }
551 m_engine = _serde::__private::Some(
552 match __A::next_value::<Pointer>(&mut __map) {
553 _serde::__private::Ok(__val) => __val,
554 _serde::__private::Err(__err) => {
555 return _serde::__private::Err(__err);
556 }
557 },
558 );
559 }
560 4usize => {
561 if _serde::__private::Option::is_some(&m_transmission) {
562 return _serde::__private::Err(
563 <__A::Error as _serde::de::Error>::duplicate_field(
564 "transmission",
565 ),
566 );
567 }
568 m_transmission = _serde::__private::Some(
569 match __A::next_value::<Pointer>(&mut __map) {
570 _serde::__private::Ok(__val) => __val,
571 _serde::__private::Err(__err) => {
572 return _serde::__private::Err(__err);
573 }
574 },
575 );
576 }
577 5usize => {
578 if _serde::__private::Option::is_some(&m_brake) {
579 return _serde::__private::Err(
580 <__A::Error as _serde::de::Error>::duplicate_field("brake"),
581 );
582 }
583 m_brake = _serde::__private::Some(
584 match __A::next_value::<Pointer>(&mut __map) {
585 _serde::__private::Ok(__val) => __val,
586 _serde::__private::Err(__err) => {
587 return _serde::__private::Err(__err);
588 }
589 },
590 );
591 }
592 6usize => {
593 if _serde::__private::Option::is_some(&m_suspension) {
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::duplicate_field(
596 "suspension",
597 ),
598 );
599 }
600 m_suspension = _serde::__private::Some(
601 match __A::next_value::<Pointer>(&mut __map) {
602 _serde::__private::Ok(__val) => __val,
603 _serde::__private::Err(__err) => {
604 return _serde::__private::Err(__err);
605 }
606 },
607 );
608 }
609 7usize => {
610 if _serde::__private::Option::is_some(&m_aerodynamics) {
611 return _serde::__private::Err(
612 <__A::Error as _serde::de::Error>::duplicate_field(
613 "aerodynamics",
614 ),
615 );
616 }
617 m_aerodynamics = _serde::__private::Some(
618 match __A::next_value::<Pointer>(&mut __map) {
619 _serde::__private::Ok(__val) => __val,
620 _serde::__private::Err(__err) => {
621 return _serde::__private::Err(__err);
622 }
623 },
624 );
625 }
626 8usize => {
627 if _serde::__private::Option::is_some(&m_wheelCollide) {
628 return _serde::__private::Err(
629 <__A::Error as _serde::de::Error>::duplicate_field(
630 "wheelCollide",
631 ),
632 );
633 }
634 m_wheelCollide = _serde::__private::Some(
635 match __A::next_value::<Pointer>(&mut __map) {
636 _serde::__private::Ok(__val) => __val,
637 _serde::__private::Err(__err) => {
638 return _serde::__private::Err(__err);
639 }
640 },
641 );
642 }
643 9usize => {
644 if _serde::__private::Option::is_some(&m_tyreMarks) {
645 return _serde::__private::Err(
646 <__A::Error as _serde::de::Error>::duplicate_field(
647 "tyreMarks",
648 ),
649 );
650 }
651 m_tyreMarks = _serde::__private::Some(
652 match __A::next_value::<Pointer>(&mut __map) {
653 _serde::__private::Ok(__val) => __val,
654 _serde::__private::Err(__err) => {
655 return _serde::__private::Err(__err);
656 }
657 },
658 );
659 }
660 10usize => {
661 if _serde::__private::Option::is_some(&m_velocityDamper) {
662 return _serde::__private::Err(
663 <__A::Error as _serde::de::Error>::duplicate_field(
664 "velocityDamper",
665 ),
666 );
667 }
668 m_velocityDamper = _serde::__private::Some(
669 match __A::next_value::<Pointer>(&mut __map) {
670 _serde::__private::Ok(__val) => __val,
671 _serde::__private::Err(__err) => {
672 return _serde::__private::Err(__err);
673 }
674 },
675 );
676 }
677 11usize => {
678 if _serde::__private::Option::is_some(&m_wheelsInfo) {
679 return _serde::__private::Err(
680 <__A::Error as _serde::de::Error>::duplicate_field(
681 "wheelsInfo",
682 ),
683 );
684 }
685 m_wheelsInfo = _serde::__private::Some(
686 match __A::next_value::<
687 Vec<hkpVehicleInstanceWheelInfo>,
688 >(&mut __map) {
689 _serde::__private::Ok(__val) => __val,
690 _serde::__private::Err(__err) => {
691 return _serde::__private::Err(__err);
692 }
693 },
694 );
695 }
696 12usize => {
697 if _serde::__private::Option::is_some(&m_frictionStatus) {
698 return _serde::__private::Err(
699 <__A::Error as _serde::de::Error>::duplicate_field(
700 "frictionStatus",
701 ),
702 );
703 }
704 m_frictionStatus = _serde::__private::Some(
705 match __A::next_value::<
706 hkpVehicleFrictionStatus,
707 >(&mut __map) {
708 _serde::__private::Ok(__val) => __val,
709 _serde::__private::Err(__err) => {
710 return _serde::__private::Err(__err);
711 }
712 },
713 );
714 }
715 13usize => {
716 if _serde::__private::Option::is_some(&m_deviceStatus) {
717 return _serde::__private::Err(
718 <__A::Error as _serde::de::Error>::duplicate_field(
719 "deviceStatus",
720 ),
721 );
722 }
723 m_deviceStatus = _serde::__private::Some(
724 match __A::next_value::<Pointer>(&mut __map) {
725 _serde::__private::Ok(__val) => __val,
726 _serde::__private::Err(__err) => {
727 return _serde::__private::Err(__err);
728 }
729 },
730 );
731 }
732 14usize => {
733 if _serde::__private::Option::is_some(&m_isFixed) {
734 return _serde::__private::Err(
735 <__A::Error as _serde::de::Error>::duplicate_field(
736 "isFixed",
737 ),
738 );
739 }
740 m_isFixed = _serde::__private::Some(
741 match __A::next_value::<Vec<bool>>(&mut __map) {
742 _serde::__private::Ok(__val) => __val,
743 _serde::__private::Err(__err) => {
744 return _serde::__private::Err(__err);
745 }
746 },
747 );
748 }
749 15usize => {
750 if _serde::__private::Option::is_some(
751 &m_wheelsTimeSinceMaxPedalInput,
752 ) {
753 return _serde::__private::Err(
754 <__A::Error as _serde::de::Error>::duplicate_field(
755 "wheelsTimeSinceMaxPedalInput",
756 ),
757 );
758 }
759 m_wheelsTimeSinceMaxPedalInput = _serde::__private::Some(
760 match __A::next_value::<f32>(&mut __map) {
761 _serde::__private::Ok(__val) => __val,
762 _serde::__private::Err(__err) => {
763 return _serde::__private::Err(__err);
764 }
765 },
766 );
767 }
768 16usize => {
769 if _serde::__private::Option::is_some(&m_tryingToReverse) {
770 return _serde::__private::Err(
771 <__A::Error as _serde::de::Error>::duplicate_field(
772 "tryingToReverse",
773 ),
774 );
775 }
776 m_tryingToReverse = _serde::__private::Some(
777 match __A::next_value::<bool>(&mut __map) {
778 _serde::__private::Ok(__val) => __val,
779 _serde::__private::Err(__err) => {
780 return _serde::__private::Err(__err);
781 }
782 },
783 );
784 }
785 17usize => {
786 if _serde::__private::Option::is_some(&m_torque) {
787 return _serde::__private::Err(
788 <__A::Error as _serde::de::Error>::duplicate_field("torque"),
789 );
790 }
791 __A::pad(&mut __map, 3usize, 3usize)?;
792 m_torque = _serde::__private::Some(
793 match __A::next_value::<f32>(&mut __map) {
794 _serde::__private::Ok(__val) => __val,
795 _serde::__private::Err(__err) => {
796 return _serde::__private::Err(__err);
797 }
798 },
799 );
800 }
801 18usize => {
802 if _serde::__private::Option::is_some(&m_rpm) {
803 return _serde::__private::Err(
804 <__A::Error as _serde::de::Error>::duplicate_field("rpm"),
805 );
806 }
807 m_rpm = _serde::__private::Some(
808 match __A::next_value::<f32>(&mut __map) {
809 _serde::__private::Ok(__val) => __val,
810 _serde::__private::Err(__err) => {
811 return _serde::__private::Err(__err);
812 }
813 },
814 );
815 }
816 19usize => {
817 if _serde::__private::Option::is_some(
818 &m_mainSteeringAngle,
819 ) {
820 return _serde::__private::Err(
821 <__A::Error as _serde::de::Error>::duplicate_field(
822 "mainSteeringAngle",
823 ),
824 );
825 }
826 m_mainSteeringAngle = _serde::__private::Some(
827 match __A::next_value::<f32>(&mut __map) {
828 _serde::__private::Ok(__val) => __val,
829 _serde::__private::Err(__err) => {
830 return _serde::__private::Err(__err);
831 }
832 },
833 );
834 }
835 20usize => {
836 if _serde::__private::Option::is_some(
837 &m_wheelsSteeringAngle,
838 ) {
839 return _serde::__private::Err(
840 <__A::Error as _serde::de::Error>::duplicate_field(
841 "wheelsSteeringAngle",
842 ),
843 );
844 }
845 __A::pad(&mut __map, 0usize, 4usize)?;
846 m_wheelsSteeringAngle = _serde::__private::Some(
847 match __A::next_value::<Vec<f32>>(&mut __map) {
848 _serde::__private::Ok(__val) => __val,
849 _serde::__private::Err(__err) => {
850 return _serde::__private::Err(__err);
851 }
852 },
853 );
854 }
855 21usize => {
856 if _serde::__private::Option::is_some(&m_isReversing) {
857 return _serde::__private::Err(
858 <__A::Error as _serde::de::Error>::duplicate_field(
859 "isReversing",
860 ),
861 );
862 }
863 m_isReversing = _serde::__private::Some(
864 match __A::next_value::<bool>(&mut __map) {
865 _serde::__private::Ok(__val) => __val,
866 _serde::__private::Err(__err) => {
867 return _serde::__private::Err(__err);
868 }
869 },
870 );
871 }
872 22usize => {
873 if _serde::__private::Option::is_some(&m_currentGear) {
874 return _serde::__private::Err(
875 <__A::Error as _serde::de::Error>::duplicate_field(
876 "currentGear",
877 ),
878 );
879 }
880 m_currentGear = _serde::__private::Some(
881 match __A::next_value::<i8>(&mut __map) {
882 _serde::__private::Ok(__val) => __val,
883 _serde::__private::Err(__err) => {
884 return _serde::__private::Err(__err);
885 }
886 },
887 );
888 }
889 23usize => {
890 if _serde::__private::Option::is_some(&m_delayed) {
891 return _serde::__private::Err(
892 <__A::Error as _serde::de::Error>::duplicate_field(
893 "delayed",
894 ),
895 );
896 }
897 m_delayed = _serde::__private::Some(
898 match __A::next_value::<bool>(&mut __map) {
899 _serde::__private::Ok(__val) => __val,
900 _serde::__private::Err(__err) => {
901 return _serde::__private::Err(__err);
902 }
903 },
904 );
905 }
906 24usize => {
907 if _serde::__private::Option::is_some(
908 &m_clutchDelayCountdown,
909 ) {
910 return _serde::__private::Err(
911 <__A::Error as _serde::de::Error>::duplicate_field(
912 "clutchDelayCountdown",
913 ),
914 );
915 }
916 __A::pad(&mut __map, 1usize, 1usize)?;
917 m_clutchDelayCountdown = _serde::__private::Some(
918 match __A::next_value::<f32>(&mut __map) {
919 _serde::__private::Ok(__val) => __val,
920 _serde::__private::Err(__err) => {
921 return _serde::__private::Err(__err);
922 }
923 },
924 );
925 }
926 _ => {}
927 }
928 }
929 let m_data = match m_data {
930 _serde::__private::Some(__field) => __field,
931 _serde::__private::None => {
932 return _serde::__private::Err(
933 <__A::Error as _serde::de::Error>::missing_field("data"),
934 );
935 }
936 };
937 let m_driverInput = match m_driverInput {
938 _serde::__private::Some(__field) => __field,
939 _serde::__private::None => {
940 return _serde::__private::Err(
941 <__A::Error as _serde::de::Error>::missing_field(
942 "driverInput",
943 ),
944 );
945 }
946 };
947 let m_steering = match m_steering {
948 _serde::__private::Some(__field) => __field,
949 _serde::__private::None => {
950 return _serde::__private::Err(
951 <__A::Error as _serde::de::Error>::missing_field("steering"),
952 );
953 }
954 };
955 let m_engine = match m_engine {
956 _serde::__private::Some(__field) => __field,
957 _serde::__private::None => {
958 return _serde::__private::Err(
959 <__A::Error as _serde::de::Error>::missing_field("engine"),
960 );
961 }
962 };
963 let m_transmission = match m_transmission {
964 _serde::__private::Some(__field) => __field,
965 _serde::__private::None => {
966 return _serde::__private::Err(
967 <__A::Error as _serde::de::Error>::missing_field(
968 "transmission",
969 ),
970 );
971 }
972 };
973 let m_brake = match m_brake {
974 _serde::__private::Some(__field) => __field,
975 _serde::__private::None => {
976 return _serde::__private::Err(
977 <__A::Error as _serde::de::Error>::missing_field("brake"),
978 );
979 }
980 };
981 let m_suspension = match m_suspension {
982 _serde::__private::Some(__field) => __field,
983 _serde::__private::None => {
984 return _serde::__private::Err(
985 <__A::Error as _serde::de::Error>::missing_field(
986 "suspension",
987 ),
988 );
989 }
990 };
991 let m_aerodynamics = match m_aerodynamics {
992 _serde::__private::Some(__field) => __field,
993 _serde::__private::None => {
994 return _serde::__private::Err(
995 <__A::Error as _serde::de::Error>::missing_field(
996 "aerodynamics",
997 ),
998 );
999 }
1000 };
1001 let m_wheelCollide = match m_wheelCollide {
1002 _serde::__private::Some(__field) => __field,
1003 _serde::__private::None => {
1004 return _serde::__private::Err(
1005 <__A::Error as _serde::de::Error>::missing_field(
1006 "wheelCollide",
1007 ),
1008 );
1009 }
1010 };
1011 let m_tyreMarks = match m_tyreMarks {
1012 _serde::__private::Some(__field) => __field,
1013 _serde::__private::None => {
1014 return _serde::__private::Err(
1015 <__A::Error as _serde::de::Error>::missing_field(
1016 "tyreMarks",
1017 ),
1018 );
1019 }
1020 };
1021 let m_velocityDamper = match m_velocityDamper {
1022 _serde::__private::Some(__field) => __field,
1023 _serde::__private::None => {
1024 return _serde::__private::Err(
1025 <__A::Error as _serde::de::Error>::missing_field(
1026 "velocityDamper",
1027 ),
1028 );
1029 }
1030 };
1031 let m_wheelsInfo = match m_wheelsInfo {
1032 _serde::__private::Some(__field) => __field,
1033 _serde::__private::None => {
1034 return _serde::__private::Err(
1035 <__A::Error as _serde::de::Error>::missing_field(
1036 "wheelsInfo",
1037 ),
1038 );
1039 }
1040 };
1041 let m_frictionStatus = match m_frictionStatus {
1042 _serde::__private::Some(__field) => __field,
1043 _serde::__private::None => {
1044 return _serde::__private::Err(
1045 <__A::Error as _serde::de::Error>::missing_field(
1046 "frictionStatus",
1047 ),
1048 );
1049 }
1050 };
1051 let m_deviceStatus = match m_deviceStatus {
1052 _serde::__private::Some(__field) => __field,
1053 _serde::__private::None => {
1054 return _serde::__private::Err(
1055 <__A::Error as _serde::de::Error>::missing_field(
1056 "deviceStatus",
1057 ),
1058 );
1059 }
1060 };
1061 let m_isFixed = match m_isFixed {
1062 _serde::__private::Some(__field) => __field,
1063 _serde::__private::None => {
1064 return _serde::__private::Err(
1065 <__A::Error as _serde::de::Error>::missing_field("isFixed"),
1066 );
1067 }
1068 };
1069 let m_wheelsTimeSinceMaxPedalInput = match m_wheelsTimeSinceMaxPedalInput {
1070 _serde::__private::Some(__field) => __field,
1071 _serde::__private::None => {
1072 return _serde::__private::Err(
1073 <__A::Error as _serde::de::Error>::missing_field(
1074 "wheelsTimeSinceMaxPedalInput",
1075 ),
1076 );
1077 }
1078 };
1079 let m_tryingToReverse = match m_tryingToReverse {
1080 _serde::__private::Some(__field) => __field,
1081 _serde::__private::None => {
1082 return _serde::__private::Err(
1083 <__A::Error as _serde::de::Error>::missing_field(
1084 "tryingToReverse",
1085 ),
1086 );
1087 }
1088 };
1089 let m_torque = match m_torque {
1090 _serde::__private::Some(__field) => __field,
1091 _serde::__private::None => {
1092 return _serde::__private::Err(
1093 <__A::Error as _serde::de::Error>::missing_field("torque"),
1094 );
1095 }
1096 };
1097 let m_rpm = match m_rpm {
1098 _serde::__private::Some(__field) => __field,
1099 _serde::__private::None => {
1100 return _serde::__private::Err(
1101 <__A::Error as _serde::de::Error>::missing_field("rpm"),
1102 );
1103 }
1104 };
1105 let m_mainSteeringAngle = match m_mainSteeringAngle {
1106 _serde::__private::Some(__field) => __field,
1107 _serde::__private::None => {
1108 return _serde::__private::Err(
1109 <__A::Error as _serde::de::Error>::missing_field(
1110 "mainSteeringAngle",
1111 ),
1112 );
1113 }
1114 };
1115 let m_wheelsSteeringAngle = match m_wheelsSteeringAngle {
1116 _serde::__private::Some(__field) => __field,
1117 _serde::__private::None => {
1118 return _serde::__private::Err(
1119 <__A::Error as _serde::de::Error>::missing_field(
1120 "wheelsSteeringAngle",
1121 ),
1122 );
1123 }
1124 };
1125 let m_isReversing = match m_isReversing {
1126 _serde::__private::Some(__field) => __field,
1127 _serde::__private::None => {
1128 return _serde::__private::Err(
1129 <__A::Error as _serde::de::Error>::missing_field(
1130 "isReversing",
1131 ),
1132 );
1133 }
1134 };
1135 let m_currentGear = match m_currentGear {
1136 _serde::__private::Some(__field) => __field,
1137 _serde::__private::None => {
1138 return _serde::__private::Err(
1139 <__A::Error as _serde::de::Error>::missing_field(
1140 "currentGear",
1141 ),
1142 );
1143 }
1144 };
1145 let m_delayed = match m_delayed {
1146 _serde::__private::Some(__field) => __field,
1147 _serde::__private::None => {
1148 return _serde::__private::Err(
1149 <__A::Error as _serde::de::Error>::missing_field("delayed"),
1150 );
1151 }
1152 };
1153 let m_clutchDelayCountdown = match m_clutchDelayCountdown {
1154 _serde::__private::Some(__field) => __field,
1155 _serde::__private::None => {
1156 return _serde::__private::Err(
1157 <__A::Error as _serde::de::Error>::missing_field(
1158 "clutchDelayCountdown",
1159 ),
1160 );
1161 }
1162 };
1163 _serde::__private::Ok(hkpVehicleInstance {
1164 __ptr,
1165 parent,
1166 m_data,
1167 m_driverInput,
1168 m_steering,
1169 m_engine,
1170 m_transmission,
1171 m_brake,
1172 m_suspension,
1173 m_aerodynamics,
1174 m_wheelCollide,
1175 m_tyreMarks,
1176 m_velocityDamper,
1177 m_wheelsInfo,
1178 m_frictionStatus,
1179 m_deviceStatus,
1180 m_isFixed,
1181 m_wheelsTimeSinceMaxPedalInput,
1182 m_tryingToReverse,
1183 m_torque,
1184 m_rpm,
1185 m_mainSteeringAngle,
1186 m_wheelsSteeringAngle,
1187 m_isReversing,
1188 m_currentGear,
1189 m_delayed,
1190 m_clutchDelayCountdown,
1191 })
1192 }
1193 #[allow(clippy::manual_unwrap_or_default)]
1194 fn visit_struct<__A>(
1195 self,
1196 mut __map: __A,
1197 ) -> _serde::__private::Result<Self::Value, __A::Error>
1198 where
1199 __A: _serde::de::MapAccess<'de>,
1200 {
1201 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1202 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1203 let mut m_entity: _serde::__private::Option<Pointer> = _serde::__private::None;
1204 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
1205 let mut m_driverInput: _serde::__private::Option<Pointer> = _serde::__private::None;
1206 let mut m_steering: _serde::__private::Option<Pointer> = _serde::__private::None;
1207 let mut m_engine: _serde::__private::Option<Pointer> = _serde::__private::None;
1208 let mut m_transmission: _serde::__private::Option<Pointer> = _serde::__private::None;
1209 let mut m_brake: _serde::__private::Option<Pointer> = _serde::__private::None;
1210 let mut m_suspension: _serde::__private::Option<Pointer> = _serde::__private::None;
1211 let mut m_aerodynamics: _serde::__private::Option<Pointer> = _serde::__private::None;
1212 let mut m_wheelCollide: _serde::__private::Option<Pointer> = _serde::__private::None;
1213 let mut m_tyreMarks: _serde::__private::Option<Pointer> = _serde::__private::None;
1214 let mut m_velocityDamper: _serde::__private::Option<Pointer> = _serde::__private::None;
1215 let mut m_wheelsInfo: _serde::__private::Option<
1216 Vec<hkpVehicleInstanceWheelInfo>,
1217 > = _serde::__private::None;
1218 let mut m_frictionStatus: _serde::__private::Option<
1219 hkpVehicleFrictionStatus,
1220 > = _serde::__private::None;
1221 let mut m_deviceStatus: _serde::__private::Option<Pointer> = _serde::__private::None;
1222 let mut m_isFixed: _serde::__private::Option<Vec<bool>> = _serde::__private::None;
1223 let mut m_wheelsTimeSinceMaxPedalInput: _serde::__private::Option<
1224 f32,
1225 > = _serde::__private::None;
1226 let mut m_tryingToReverse: _serde::__private::Option<bool> = _serde::__private::None;
1227 let mut m_torque: _serde::__private::Option<f32> = _serde::__private::None;
1228 let mut m_rpm: _serde::__private::Option<f32> = _serde::__private::None;
1229 let mut m_mainSteeringAngle: _serde::__private::Option<f32> = _serde::__private::None;
1230 let mut m_wheelsSteeringAngle: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
1231 let mut m_isReversing: _serde::__private::Option<bool> = _serde::__private::None;
1232 let mut m_currentGear: _serde::__private::Option<i8> = _serde::__private::None;
1233 let mut m_delayed: _serde::__private::Option<bool> = _serde::__private::None;
1234 let mut m_clutchDelayCountdown: _serde::__private::Option<f32> = _serde::__private::None;
1235 while let _serde::__private::Some(__key) = {
1236 __A::next_key::<__Field>(&mut __map)?
1237 } {
1238 match __key {
1239 __Field::m_userData => {
1240 #[cfg(
1241 any(feature = "strict", feature = "ignore_duplicates")
1242 )]
1243 if _serde::__private::Option::is_some(&m_userData) {
1244 #[cfg(feature = "ignore_duplicates")]
1245 {
1246 __A::skip_value(&mut __map)?;
1247 continue;
1248 }
1249 #[cfg(feature = "strict")]
1250 return _serde::__private::Err(
1251 <__A::Error as _serde::de::Error>::duplicate_field(
1252 "userData",
1253 ),
1254 );
1255 }
1256 m_userData = _serde::__private::Some(
1257 match __A::next_value::<Ulong>(&mut __map) {
1258 _serde::__private::Ok(__val) => __val,
1259 _serde::__private::Err(__err) => {
1260 return _serde::__private::Err(__err);
1261 }
1262 },
1263 );
1264 }
1265 __Field::m_name => {
1266 #[cfg(
1267 any(feature = "strict", feature = "ignore_duplicates")
1268 )]
1269 if _serde::__private::Option::is_some(&m_name) {
1270 #[cfg(feature = "ignore_duplicates")]
1271 {
1272 __A::skip_value(&mut __map)?;
1273 continue;
1274 }
1275 #[cfg(feature = "strict")]
1276 return _serde::__private::Err(
1277 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1278 );
1279 }
1280 m_name = _serde::__private::Some(
1281 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1282 _serde::__private::Ok(__val) => __val,
1283 _serde::__private::Err(__err) => {
1284 return _serde::__private::Err(__err);
1285 }
1286 },
1287 );
1288 }
1289 __Field::m_entity => {
1290 #[cfg(
1291 any(feature = "strict", feature = "ignore_duplicates")
1292 )]
1293 if _serde::__private::Option::is_some(&m_entity) {
1294 #[cfg(feature = "ignore_duplicates")]
1295 {
1296 __A::skip_value(&mut __map)?;
1297 continue;
1298 }
1299 #[cfg(feature = "strict")]
1300 return _serde::__private::Err(
1301 <__A::Error as _serde::de::Error>::duplicate_field("entity"),
1302 );
1303 }
1304 m_entity = _serde::__private::Some(
1305 match __A::next_value::<Pointer>(&mut __map) {
1306 _serde::__private::Ok(__val) => __val,
1307 _serde::__private::Err(__err) => {
1308 return _serde::__private::Err(__err);
1309 }
1310 },
1311 );
1312 }
1313 __Field::m_data => {
1314 #[cfg(
1315 any(feature = "strict", feature = "ignore_duplicates")
1316 )]
1317 if _serde::__private::Option::is_some(&m_data) {
1318 #[cfg(feature = "ignore_duplicates")]
1319 {
1320 __A::skip_value(&mut __map)?;
1321 continue;
1322 }
1323 #[cfg(feature = "strict")]
1324 return _serde::__private::Err(
1325 <__A::Error as _serde::de::Error>::duplicate_field("data"),
1326 );
1327 }
1328 m_data = _serde::__private::Some(
1329 match __A::next_value::<Pointer>(&mut __map) {
1330 _serde::__private::Ok(__val) => __val,
1331 _serde::__private::Err(__err) => {
1332 return _serde::__private::Err(__err);
1333 }
1334 },
1335 );
1336 }
1337 __Field::m_driverInput => {
1338 #[cfg(
1339 any(feature = "strict", feature = "ignore_duplicates")
1340 )]
1341 if _serde::__private::Option::is_some(&m_driverInput) {
1342 #[cfg(feature = "ignore_duplicates")]
1343 {
1344 __A::skip_value(&mut __map)?;
1345 continue;
1346 }
1347 #[cfg(feature = "strict")]
1348 return _serde::__private::Err(
1349 <__A::Error as _serde::de::Error>::duplicate_field(
1350 "driverInput",
1351 ),
1352 );
1353 }
1354 m_driverInput = _serde::__private::Some(
1355 match __A::next_value::<Pointer>(&mut __map) {
1356 _serde::__private::Ok(__val) => __val,
1357 _serde::__private::Err(__err) => {
1358 return _serde::__private::Err(__err);
1359 }
1360 },
1361 );
1362 }
1363 __Field::m_steering => {
1364 #[cfg(
1365 any(feature = "strict", feature = "ignore_duplicates")
1366 )]
1367 if _serde::__private::Option::is_some(&m_steering) {
1368 #[cfg(feature = "ignore_duplicates")]
1369 {
1370 __A::skip_value(&mut __map)?;
1371 continue;
1372 }
1373 #[cfg(feature = "strict")]
1374 return _serde::__private::Err(
1375 <__A::Error as _serde::de::Error>::duplicate_field(
1376 "steering",
1377 ),
1378 );
1379 }
1380 m_steering = _serde::__private::Some(
1381 match __A::next_value::<Pointer>(&mut __map) {
1382 _serde::__private::Ok(__val) => __val,
1383 _serde::__private::Err(__err) => {
1384 return _serde::__private::Err(__err);
1385 }
1386 },
1387 );
1388 }
1389 __Field::m_engine => {
1390 #[cfg(
1391 any(feature = "strict", feature = "ignore_duplicates")
1392 )]
1393 if _serde::__private::Option::is_some(&m_engine) {
1394 #[cfg(feature = "ignore_duplicates")]
1395 {
1396 __A::skip_value(&mut __map)?;
1397 continue;
1398 }
1399 #[cfg(feature = "strict")]
1400 return _serde::__private::Err(
1401 <__A::Error as _serde::de::Error>::duplicate_field("engine"),
1402 );
1403 }
1404 m_engine = _serde::__private::Some(
1405 match __A::next_value::<Pointer>(&mut __map) {
1406 _serde::__private::Ok(__val) => __val,
1407 _serde::__private::Err(__err) => {
1408 return _serde::__private::Err(__err);
1409 }
1410 },
1411 );
1412 }
1413 __Field::m_transmission => {
1414 #[cfg(
1415 any(feature = "strict", feature = "ignore_duplicates")
1416 )]
1417 if _serde::__private::Option::is_some(&m_transmission) {
1418 #[cfg(feature = "ignore_duplicates")]
1419 {
1420 __A::skip_value(&mut __map)?;
1421 continue;
1422 }
1423 #[cfg(feature = "strict")]
1424 return _serde::__private::Err(
1425 <__A::Error as _serde::de::Error>::duplicate_field(
1426 "transmission",
1427 ),
1428 );
1429 }
1430 m_transmission = _serde::__private::Some(
1431 match __A::next_value::<Pointer>(&mut __map) {
1432 _serde::__private::Ok(__val) => __val,
1433 _serde::__private::Err(__err) => {
1434 return _serde::__private::Err(__err);
1435 }
1436 },
1437 );
1438 }
1439 __Field::m_brake => {
1440 #[cfg(
1441 any(feature = "strict", feature = "ignore_duplicates")
1442 )]
1443 if _serde::__private::Option::is_some(&m_brake) {
1444 #[cfg(feature = "ignore_duplicates")]
1445 {
1446 __A::skip_value(&mut __map)?;
1447 continue;
1448 }
1449 #[cfg(feature = "strict")]
1450 return _serde::__private::Err(
1451 <__A::Error as _serde::de::Error>::duplicate_field("brake"),
1452 );
1453 }
1454 m_brake = _serde::__private::Some(
1455 match __A::next_value::<Pointer>(&mut __map) {
1456 _serde::__private::Ok(__val) => __val,
1457 _serde::__private::Err(__err) => {
1458 return _serde::__private::Err(__err);
1459 }
1460 },
1461 );
1462 }
1463 __Field::m_suspension => {
1464 #[cfg(
1465 any(feature = "strict", feature = "ignore_duplicates")
1466 )]
1467 if _serde::__private::Option::is_some(&m_suspension) {
1468 #[cfg(feature = "ignore_duplicates")]
1469 {
1470 __A::skip_value(&mut __map)?;
1471 continue;
1472 }
1473 #[cfg(feature = "strict")]
1474 return _serde::__private::Err(
1475 <__A::Error as _serde::de::Error>::duplicate_field(
1476 "suspension",
1477 ),
1478 );
1479 }
1480 m_suspension = _serde::__private::Some(
1481 match __A::next_value::<Pointer>(&mut __map) {
1482 _serde::__private::Ok(__val) => __val,
1483 _serde::__private::Err(__err) => {
1484 return _serde::__private::Err(__err);
1485 }
1486 },
1487 );
1488 }
1489 __Field::m_aerodynamics => {
1490 #[cfg(
1491 any(feature = "strict", feature = "ignore_duplicates")
1492 )]
1493 if _serde::__private::Option::is_some(&m_aerodynamics) {
1494 #[cfg(feature = "ignore_duplicates")]
1495 {
1496 __A::skip_value(&mut __map)?;
1497 continue;
1498 }
1499 #[cfg(feature = "strict")]
1500 return _serde::__private::Err(
1501 <__A::Error as _serde::de::Error>::duplicate_field(
1502 "aerodynamics",
1503 ),
1504 );
1505 }
1506 m_aerodynamics = _serde::__private::Some(
1507 match __A::next_value::<Pointer>(&mut __map) {
1508 _serde::__private::Ok(__val) => __val,
1509 _serde::__private::Err(__err) => {
1510 return _serde::__private::Err(__err);
1511 }
1512 },
1513 );
1514 }
1515 __Field::m_wheelCollide => {
1516 #[cfg(
1517 any(feature = "strict", feature = "ignore_duplicates")
1518 )]
1519 if _serde::__private::Option::is_some(&m_wheelCollide) {
1520 #[cfg(feature = "ignore_duplicates")]
1521 {
1522 __A::skip_value(&mut __map)?;
1523 continue;
1524 }
1525 #[cfg(feature = "strict")]
1526 return _serde::__private::Err(
1527 <__A::Error as _serde::de::Error>::duplicate_field(
1528 "wheelCollide",
1529 ),
1530 );
1531 }
1532 m_wheelCollide = _serde::__private::Some(
1533 match __A::next_value::<Pointer>(&mut __map) {
1534 _serde::__private::Ok(__val) => __val,
1535 _serde::__private::Err(__err) => {
1536 return _serde::__private::Err(__err);
1537 }
1538 },
1539 );
1540 }
1541 __Field::m_tyreMarks => {
1542 #[cfg(
1543 any(feature = "strict", feature = "ignore_duplicates")
1544 )]
1545 if _serde::__private::Option::is_some(&m_tyreMarks) {
1546 #[cfg(feature = "ignore_duplicates")]
1547 {
1548 __A::skip_value(&mut __map)?;
1549 continue;
1550 }
1551 #[cfg(feature = "strict")]
1552 return _serde::__private::Err(
1553 <__A::Error as _serde::de::Error>::duplicate_field(
1554 "tyreMarks",
1555 ),
1556 );
1557 }
1558 m_tyreMarks = _serde::__private::Some(
1559 match __A::next_value::<Pointer>(&mut __map) {
1560 _serde::__private::Ok(__val) => __val,
1561 _serde::__private::Err(__err) => {
1562 return _serde::__private::Err(__err);
1563 }
1564 },
1565 );
1566 }
1567 __Field::m_velocityDamper => {
1568 #[cfg(
1569 any(feature = "strict", feature = "ignore_duplicates")
1570 )]
1571 if _serde::__private::Option::is_some(&m_velocityDamper) {
1572 #[cfg(feature = "ignore_duplicates")]
1573 {
1574 __A::skip_value(&mut __map)?;
1575 continue;
1576 }
1577 #[cfg(feature = "strict")]
1578 return _serde::__private::Err(
1579 <__A::Error as _serde::de::Error>::duplicate_field(
1580 "velocityDamper",
1581 ),
1582 );
1583 }
1584 m_velocityDamper = _serde::__private::Some(
1585 match __A::next_value::<Pointer>(&mut __map) {
1586 _serde::__private::Ok(__val) => __val,
1587 _serde::__private::Err(__err) => {
1588 return _serde::__private::Err(__err);
1589 }
1590 },
1591 );
1592 }
1593 __Field::m_wheelsInfo => {
1594 #[cfg(
1595 any(feature = "strict", feature = "ignore_duplicates")
1596 )]
1597 if _serde::__private::Option::is_some(&m_wheelsInfo) {
1598 #[cfg(feature = "ignore_duplicates")]
1599 {
1600 __A::skip_value(&mut __map)?;
1601 continue;
1602 }
1603 #[cfg(feature = "strict")]
1604 return _serde::__private::Err(
1605 <__A::Error as _serde::de::Error>::duplicate_field(
1606 "wheelsInfo",
1607 ),
1608 );
1609 }
1610 m_wheelsInfo = _serde::__private::Some(
1611 match __A::next_value::<
1612 Vec<hkpVehicleInstanceWheelInfo>,
1613 >(&mut __map) {
1614 _serde::__private::Ok(__val) => __val,
1615 _serde::__private::Err(__err) => {
1616 return _serde::__private::Err(__err);
1617 }
1618 },
1619 );
1620 }
1621 __Field::m_frictionStatus => {
1622 #[cfg(
1623 any(feature = "strict", feature = "ignore_duplicates")
1624 )]
1625 if _serde::__private::Option::is_some(&m_frictionStatus) {
1626 #[cfg(feature = "ignore_duplicates")]
1627 {
1628 __A::skip_value(&mut __map)?;
1629 continue;
1630 }
1631 #[cfg(feature = "strict")]
1632 return _serde::__private::Err(
1633 <__A::Error as _serde::de::Error>::duplicate_field(
1634 "frictionStatus",
1635 ),
1636 );
1637 }
1638 m_frictionStatus = _serde::__private::Some(
1639 match __A::next_value::<
1640 hkpVehicleFrictionStatus,
1641 >(&mut __map) {
1642 _serde::__private::Ok(__val) => __val,
1643 _serde::__private::Err(__err) => {
1644 return _serde::__private::Err(__err);
1645 }
1646 },
1647 );
1648 }
1649 __Field::m_deviceStatus => {
1650 #[cfg(
1651 any(feature = "strict", feature = "ignore_duplicates")
1652 )]
1653 if _serde::__private::Option::is_some(&m_deviceStatus) {
1654 #[cfg(feature = "ignore_duplicates")]
1655 {
1656 __A::skip_value(&mut __map)?;
1657 continue;
1658 }
1659 #[cfg(feature = "strict")]
1660 return _serde::__private::Err(
1661 <__A::Error as _serde::de::Error>::duplicate_field(
1662 "deviceStatus",
1663 ),
1664 );
1665 }
1666 m_deviceStatus = _serde::__private::Some(
1667 match __A::next_value::<Pointer>(&mut __map) {
1668 _serde::__private::Ok(__val) => __val,
1669 _serde::__private::Err(__err) => {
1670 return _serde::__private::Err(__err);
1671 }
1672 },
1673 );
1674 }
1675 __Field::m_isFixed => {
1676 #[cfg(
1677 any(feature = "strict", feature = "ignore_duplicates")
1678 )]
1679 if _serde::__private::Option::is_some(&m_isFixed) {
1680 #[cfg(feature = "ignore_duplicates")]
1681 {
1682 __A::skip_value(&mut __map)?;
1683 continue;
1684 }
1685 #[cfg(feature = "strict")]
1686 return _serde::__private::Err(
1687 <__A::Error as _serde::de::Error>::duplicate_field(
1688 "isFixed",
1689 ),
1690 );
1691 }
1692 m_isFixed = _serde::__private::Some(
1693 match __A::next_value::<Vec<bool>>(&mut __map) {
1694 _serde::__private::Ok(__val) => __val,
1695 _serde::__private::Err(__err) => {
1696 return _serde::__private::Err(__err);
1697 }
1698 },
1699 );
1700 }
1701 __Field::m_wheelsTimeSinceMaxPedalInput => {
1702 #[cfg(
1703 any(feature = "strict", feature = "ignore_duplicates")
1704 )]
1705 if _serde::__private::Option::is_some(
1706 &m_wheelsTimeSinceMaxPedalInput,
1707 ) {
1708 #[cfg(feature = "ignore_duplicates")]
1709 {
1710 __A::skip_value(&mut __map)?;
1711 continue;
1712 }
1713 #[cfg(feature = "strict")]
1714 return _serde::__private::Err(
1715 <__A::Error as _serde::de::Error>::duplicate_field(
1716 "wheelsTimeSinceMaxPedalInput",
1717 ),
1718 );
1719 }
1720 m_wheelsTimeSinceMaxPedalInput = _serde::__private::Some(
1721 match __A::next_value::<f32>(&mut __map) {
1722 _serde::__private::Ok(__val) => __val,
1723 _serde::__private::Err(__err) => {
1724 return _serde::__private::Err(__err);
1725 }
1726 },
1727 );
1728 }
1729 __Field::m_tryingToReverse => {
1730 #[cfg(
1731 any(feature = "strict", feature = "ignore_duplicates")
1732 )]
1733 if _serde::__private::Option::is_some(&m_tryingToReverse) {
1734 #[cfg(feature = "ignore_duplicates")]
1735 {
1736 __A::skip_value(&mut __map)?;
1737 continue;
1738 }
1739 #[cfg(feature = "strict")]
1740 return _serde::__private::Err(
1741 <__A::Error as _serde::de::Error>::duplicate_field(
1742 "tryingToReverse",
1743 ),
1744 );
1745 }
1746 m_tryingToReverse = _serde::__private::Some(
1747 match __A::next_value::<bool>(&mut __map) {
1748 _serde::__private::Ok(__val) => __val,
1749 _serde::__private::Err(__err) => {
1750 return _serde::__private::Err(__err);
1751 }
1752 },
1753 );
1754 }
1755 __Field::m_torque => {
1756 #[cfg(
1757 any(feature = "strict", feature = "ignore_duplicates")
1758 )]
1759 if _serde::__private::Option::is_some(&m_torque) {
1760 #[cfg(feature = "ignore_duplicates")]
1761 {
1762 __A::skip_value(&mut __map)?;
1763 continue;
1764 }
1765 #[cfg(feature = "strict")]
1766 return _serde::__private::Err(
1767 <__A::Error as _serde::de::Error>::duplicate_field("torque"),
1768 );
1769 }
1770 m_torque = _serde::__private::Some(
1771 match __A::next_value::<f32>(&mut __map) {
1772 _serde::__private::Ok(__val) => __val,
1773 _serde::__private::Err(__err) => {
1774 return _serde::__private::Err(__err);
1775 }
1776 },
1777 );
1778 }
1779 __Field::m_rpm => {
1780 #[cfg(
1781 any(feature = "strict", feature = "ignore_duplicates")
1782 )]
1783 if _serde::__private::Option::is_some(&m_rpm) {
1784 #[cfg(feature = "ignore_duplicates")]
1785 {
1786 __A::skip_value(&mut __map)?;
1787 continue;
1788 }
1789 #[cfg(feature = "strict")]
1790 return _serde::__private::Err(
1791 <__A::Error as _serde::de::Error>::duplicate_field("rpm"),
1792 );
1793 }
1794 m_rpm = _serde::__private::Some(
1795 match __A::next_value::<f32>(&mut __map) {
1796 _serde::__private::Ok(__val) => __val,
1797 _serde::__private::Err(__err) => {
1798 return _serde::__private::Err(__err);
1799 }
1800 },
1801 );
1802 }
1803 __Field::m_mainSteeringAngle => {
1804 #[cfg(
1805 any(feature = "strict", feature = "ignore_duplicates")
1806 )]
1807 if _serde::__private::Option::is_some(
1808 &m_mainSteeringAngle,
1809 ) {
1810 #[cfg(feature = "ignore_duplicates")]
1811 {
1812 __A::skip_value(&mut __map)?;
1813 continue;
1814 }
1815 #[cfg(feature = "strict")]
1816 return _serde::__private::Err(
1817 <__A::Error as _serde::de::Error>::duplicate_field(
1818 "mainSteeringAngle",
1819 ),
1820 );
1821 }
1822 m_mainSteeringAngle = _serde::__private::Some(
1823 match __A::next_value::<f32>(&mut __map) {
1824 _serde::__private::Ok(__val) => __val,
1825 _serde::__private::Err(__err) => {
1826 return _serde::__private::Err(__err);
1827 }
1828 },
1829 );
1830 }
1831 __Field::m_wheelsSteeringAngle => {
1832 #[cfg(
1833 any(feature = "strict", feature = "ignore_duplicates")
1834 )]
1835 if _serde::__private::Option::is_some(
1836 &m_wheelsSteeringAngle,
1837 ) {
1838 #[cfg(feature = "ignore_duplicates")]
1839 {
1840 __A::skip_value(&mut __map)?;
1841 continue;
1842 }
1843 #[cfg(feature = "strict")]
1844 return _serde::__private::Err(
1845 <__A::Error as _serde::de::Error>::duplicate_field(
1846 "wheelsSteeringAngle",
1847 ),
1848 );
1849 }
1850 m_wheelsSteeringAngle = _serde::__private::Some(
1851 match __A::next_value::<Vec<f32>>(&mut __map) {
1852 _serde::__private::Ok(__val) => __val,
1853 _serde::__private::Err(__err) => {
1854 return _serde::__private::Err(__err);
1855 }
1856 },
1857 );
1858 }
1859 __Field::m_isReversing => {
1860 #[cfg(
1861 any(feature = "strict", feature = "ignore_duplicates")
1862 )]
1863 if _serde::__private::Option::is_some(&m_isReversing) {
1864 #[cfg(feature = "ignore_duplicates")]
1865 {
1866 __A::skip_value(&mut __map)?;
1867 continue;
1868 }
1869 #[cfg(feature = "strict")]
1870 return _serde::__private::Err(
1871 <__A::Error as _serde::de::Error>::duplicate_field(
1872 "isReversing",
1873 ),
1874 );
1875 }
1876 m_isReversing = _serde::__private::Some(
1877 match __A::next_value::<bool>(&mut __map) {
1878 _serde::__private::Ok(__val) => __val,
1879 _serde::__private::Err(__err) => {
1880 return _serde::__private::Err(__err);
1881 }
1882 },
1883 );
1884 }
1885 __Field::m_currentGear => {
1886 #[cfg(
1887 any(feature = "strict", feature = "ignore_duplicates")
1888 )]
1889 if _serde::__private::Option::is_some(&m_currentGear) {
1890 #[cfg(feature = "ignore_duplicates")]
1891 {
1892 __A::skip_value(&mut __map)?;
1893 continue;
1894 }
1895 #[cfg(feature = "strict")]
1896 return _serde::__private::Err(
1897 <__A::Error as _serde::de::Error>::duplicate_field(
1898 "currentGear",
1899 ),
1900 );
1901 }
1902 m_currentGear = _serde::__private::Some(
1903 match __A::next_value::<i8>(&mut __map) {
1904 _serde::__private::Ok(__val) => __val,
1905 _serde::__private::Err(__err) => {
1906 return _serde::__private::Err(__err);
1907 }
1908 },
1909 );
1910 }
1911 __Field::m_delayed => {
1912 #[cfg(
1913 any(feature = "strict", feature = "ignore_duplicates")
1914 )]
1915 if _serde::__private::Option::is_some(&m_delayed) {
1916 #[cfg(feature = "ignore_duplicates")]
1917 {
1918 __A::skip_value(&mut __map)?;
1919 continue;
1920 }
1921 #[cfg(feature = "strict")]
1922 return _serde::__private::Err(
1923 <__A::Error as _serde::de::Error>::duplicate_field(
1924 "delayed",
1925 ),
1926 );
1927 }
1928 m_delayed = _serde::__private::Some(
1929 match __A::next_value::<bool>(&mut __map) {
1930 _serde::__private::Ok(__val) => __val,
1931 _serde::__private::Err(__err) => {
1932 return _serde::__private::Err(__err);
1933 }
1934 },
1935 );
1936 }
1937 __Field::m_clutchDelayCountdown => {
1938 #[cfg(
1939 any(feature = "strict", feature = "ignore_duplicates")
1940 )]
1941 if _serde::__private::Option::is_some(
1942 &m_clutchDelayCountdown,
1943 ) {
1944 #[cfg(feature = "ignore_duplicates")]
1945 {
1946 __A::skip_value(&mut __map)?;
1947 continue;
1948 }
1949 #[cfg(feature = "strict")]
1950 return _serde::__private::Err(
1951 <__A::Error as _serde::de::Error>::duplicate_field(
1952 "clutchDelayCountdown",
1953 ),
1954 );
1955 }
1956 m_clutchDelayCountdown = _serde::__private::Some(
1957 match __A::next_value::<f32>(&mut __map) {
1958 _serde::__private::Ok(__val) => __val,
1959 _serde::__private::Err(__err) => {
1960 return _serde::__private::Err(__err);
1961 }
1962 },
1963 );
1964 }
1965 _ => __A::skip_value(&mut __map)?,
1966 }
1967 }
1968 let m_userData = match m_userData {
1969 _serde::__private::Some(__field) => __field,
1970 _serde::__private::None => {
1971 #[cfg(feature = "strict")]
1972 return _serde::__private::Err(
1973 <__A::Error as _serde::de::Error>::missing_field("userData"),
1974 );
1975 #[cfg(not(feature = "strict"))] Default::default()
1976 }
1977 };
1978 let m_name = match m_name {
1979 _serde::__private::Some(__field) => __field,
1980 _serde::__private::None => {
1981 #[cfg(feature = "strict")]
1982 return _serde::__private::Err(
1983 <__A::Error as _serde::de::Error>::missing_field("name"),
1984 );
1985 #[cfg(not(feature = "strict"))] Default::default()
1986 }
1987 };
1988 let m_entity = match m_entity {
1989 _serde::__private::Some(__field) => __field,
1990 _serde::__private::None => {
1991 #[cfg(feature = "strict")]
1992 return _serde::__private::Err(
1993 <__A::Error as _serde::de::Error>::missing_field("entity"),
1994 );
1995 #[cfg(not(feature = "strict"))] Default::default()
1996 }
1997 };
1998 let m_data = match m_data {
1999 _serde::__private::Some(__field) => __field,
2000 _serde::__private::None => {
2001 #[cfg(feature = "strict")]
2002 return _serde::__private::Err(
2003 <__A::Error as _serde::de::Error>::missing_field("data"),
2004 );
2005 #[cfg(not(feature = "strict"))] Default::default()
2006 }
2007 };
2008 let m_driverInput = match m_driverInput {
2009 _serde::__private::Some(__field) => __field,
2010 _serde::__private::None => {
2011 #[cfg(feature = "strict")]
2012 return _serde::__private::Err(
2013 <__A::Error as _serde::de::Error>::missing_field(
2014 "driverInput",
2015 ),
2016 );
2017 #[cfg(not(feature = "strict"))] Default::default()
2018 }
2019 };
2020 let m_steering = match m_steering {
2021 _serde::__private::Some(__field) => __field,
2022 _serde::__private::None => {
2023 #[cfg(feature = "strict")]
2024 return _serde::__private::Err(
2025 <__A::Error as _serde::de::Error>::missing_field("steering"),
2026 );
2027 #[cfg(not(feature = "strict"))] Default::default()
2028 }
2029 };
2030 let m_engine = match m_engine {
2031 _serde::__private::Some(__field) => __field,
2032 _serde::__private::None => {
2033 #[cfg(feature = "strict")]
2034 return _serde::__private::Err(
2035 <__A::Error as _serde::de::Error>::missing_field("engine"),
2036 );
2037 #[cfg(not(feature = "strict"))] Default::default()
2038 }
2039 };
2040 let m_transmission = match m_transmission {
2041 _serde::__private::Some(__field) => __field,
2042 _serde::__private::None => {
2043 #[cfg(feature = "strict")]
2044 return _serde::__private::Err(
2045 <__A::Error as _serde::de::Error>::missing_field(
2046 "transmission",
2047 ),
2048 );
2049 #[cfg(not(feature = "strict"))] Default::default()
2050 }
2051 };
2052 let m_brake = match m_brake {
2053 _serde::__private::Some(__field) => __field,
2054 _serde::__private::None => {
2055 #[cfg(feature = "strict")]
2056 return _serde::__private::Err(
2057 <__A::Error as _serde::de::Error>::missing_field("brake"),
2058 );
2059 #[cfg(not(feature = "strict"))] Default::default()
2060 }
2061 };
2062 let m_suspension = match m_suspension {
2063 _serde::__private::Some(__field) => __field,
2064 _serde::__private::None => {
2065 #[cfg(feature = "strict")]
2066 return _serde::__private::Err(
2067 <__A::Error as _serde::de::Error>::missing_field(
2068 "suspension",
2069 ),
2070 );
2071 #[cfg(not(feature = "strict"))] Default::default()
2072 }
2073 };
2074 let m_aerodynamics = match m_aerodynamics {
2075 _serde::__private::Some(__field) => __field,
2076 _serde::__private::None => {
2077 #[cfg(feature = "strict")]
2078 return _serde::__private::Err(
2079 <__A::Error as _serde::de::Error>::missing_field(
2080 "aerodynamics",
2081 ),
2082 );
2083 #[cfg(not(feature = "strict"))] Default::default()
2084 }
2085 };
2086 let m_wheelCollide = match m_wheelCollide {
2087 _serde::__private::Some(__field) => __field,
2088 _serde::__private::None => {
2089 #[cfg(feature = "strict")]
2090 return _serde::__private::Err(
2091 <__A::Error as _serde::de::Error>::missing_field(
2092 "wheelCollide",
2093 ),
2094 );
2095 #[cfg(not(feature = "strict"))] Default::default()
2096 }
2097 };
2098 let m_tyreMarks = match m_tyreMarks {
2099 _serde::__private::Some(__field) => __field,
2100 _serde::__private::None => {
2101 #[cfg(feature = "strict")]
2102 return _serde::__private::Err(
2103 <__A::Error as _serde::de::Error>::missing_field(
2104 "tyreMarks",
2105 ),
2106 );
2107 #[cfg(not(feature = "strict"))] Default::default()
2108 }
2109 };
2110 let m_velocityDamper = match m_velocityDamper {
2111 _serde::__private::Some(__field) => __field,
2112 _serde::__private::None => {
2113 #[cfg(feature = "strict")]
2114 return _serde::__private::Err(
2115 <__A::Error as _serde::de::Error>::missing_field(
2116 "velocityDamper",
2117 ),
2118 );
2119 #[cfg(not(feature = "strict"))] Default::default()
2120 }
2121 };
2122 let m_wheelsInfo = match m_wheelsInfo {
2123 _serde::__private::Some(__field) => __field,
2124 _serde::__private::None => {
2125 #[cfg(feature = "strict")]
2126 return _serde::__private::Err(
2127 <__A::Error as _serde::de::Error>::missing_field(
2128 "wheelsInfo",
2129 ),
2130 );
2131 #[cfg(not(feature = "strict"))] Default::default()
2132 }
2133 };
2134 let m_frictionStatus = match m_frictionStatus {
2135 _serde::__private::Some(__field) => __field,
2136 _serde::__private::None => {
2137 #[cfg(feature = "strict")]
2138 return _serde::__private::Err(
2139 <__A::Error as _serde::de::Error>::missing_field(
2140 "frictionStatus",
2141 ),
2142 );
2143 #[cfg(not(feature = "strict"))] Default::default()
2144 }
2145 };
2146 let m_deviceStatus = match m_deviceStatus {
2147 _serde::__private::Some(__field) => __field,
2148 _serde::__private::None => {
2149 #[cfg(feature = "strict")]
2150 return _serde::__private::Err(
2151 <__A::Error as _serde::de::Error>::missing_field(
2152 "deviceStatus",
2153 ),
2154 );
2155 #[cfg(not(feature = "strict"))] Default::default()
2156 }
2157 };
2158 let m_isFixed = match m_isFixed {
2159 _serde::__private::Some(__field) => __field,
2160 _serde::__private::None => {
2161 #[cfg(feature = "strict")]
2162 return _serde::__private::Err(
2163 <__A::Error as _serde::de::Error>::missing_field("isFixed"),
2164 );
2165 #[cfg(not(feature = "strict"))] Default::default()
2166 }
2167 };
2168 let m_wheelsTimeSinceMaxPedalInput = match m_wheelsTimeSinceMaxPedalInput {
2169 _serde::__private::Some(__field) => __field,
2170 _serde::__private::None => {
2171 #[cfg(feature = "strict")]
2172 return _serde::__private::Err(
2173 <__A::Error as _serde::de::Error>::missing_field(
2174 "wheelsTimeSinceMaxPedalInput",
2175 ),
2176 );
2177 #[cfg(not(feature = "strict"))] Default::default()
2178 }
2179 };
2180 let m_tryingToReverse = match m_tryingToReverse {
2181 _serde::__private::Some(__field) => __field,
2182 _serde::__private::None => {
2183 #[cfg(feature = "strict")]
2184 return _serde::__private::Err(
2185 <__A::Error as _serde::de::Error>::missing_field(
2186 "tryingToReverse",
2187 ),
2188 );
2189 #[cfg(not(feature = "strict"))] Default::default()
2190 }
2191 };
2192 let m_torque = match m_torque {
2193 _serde::__private::Some(__field) => __field,
2194 _serde::__private::None => {
2195 #[cfg(feature = "strict")]
2196 return _serde::__private::Err(
2197 <__A::Error as _serde::de::Error>::missing_field("torque"),
2198 );
2199 #[cfg(not(feature = "strict"))] Default::default()
2200 }
2201 };
2202 let m_rpm = match m_rpm {
2203 _serde::__private::Some(__field) => __field,
2204 _serde::__private::None => {
2205 #[cfg(feature = "strict")]
2206 return _serde::__private::Err(
2207 <__A::Error as _serde::de::Error>::missing_field("rpm"),
2208 );
2209 #[cfg(not(feature = "strict"))] Default::default()
2210 }
2211 };
2212 let m_mainSteeringAngle = match m_mainSteeringAngle {
2213 _serde::__private::Some(__field) => __field,
2214 _serde::__private::None => {
2215 #[cfg(feature = "strict")]
2216 return _serde::__private::Err(
2217 <__A::Error as _serde::de::Error>::missing_field(
2218 "mainSteeringAngle",
2219 ),
2220 );
2221 #[cfg(not(feature = "strict"))] Default::default()
2222 }
2223 };
2224 let m_wheelsSteeringAngle = match m_wheelsSteeringAngle {
2225 _serde::__private::Some(__field) => __field,
2226 _serde::__private::None => {
2227 #[cfg(feature = "strict")]
2228 return _serde::__private::Err(
2229 <__A::Error as _serde::de::Error>::missing_field(
2230 "wheelsSteeringAngle",
2231 ),
2232 );
2233 #[cfg(not(feature = "strict"))] Default::default()
2234 }
2235 };
2236 let m_isReversing = match m_isReversing {
2237 _serde::__private::Some(__field) => __field,
2238 _serde::__private::None => {
2239 #[cfg(feature = "strict")]
2240 return _serde::__private::Err(
2241 <__A::Error as _serde::de::Error>::missing_field(
2242 "isReversing",
2243 ),
2244 );
2245 #[cfg(not(feature = "strict"))] Default::default()
2246 }
2247 };
2248 let m_currentGear = match m_currentGear {
2249 _serde::__private::Some(__field) => __field,
2250 _serde::__private::None => {
2251 #[cfg(feature = "strict")]
2252 return _serde::__private::Err(
2253 <__A::Error as _serde::de::Error>::missing_field(
2254 "currentGear",
2255 ),
2256 );
2257 #[cfg(not(feature = "strict"))] Default::default()
2258 }
2259 };
2260 let m_delayed = match m_delayed {
2261 _serde::__private::Some(__field) => __field,
2262 _serde::__private::None => {
2263 #[cfg(feature = "strict")]
2264 return _serde::__private::Err(
2265 <__A::Error as _serde::de::Error>::missing_field("delayed"),
2266 );
2267 #[cfg(not(feature = "strict"))] Default::default()
2268 }
2269 };
2270 let m_clutchDelayCountdown = match m_clutchDelayCountdown {
2271 _serde::__private::Some(__field) => __field,
2272 _serde::__private::None => {
2273 #[cfg(feature = "strict")]
2274 return _serde::__private::Err(
2275 <__A::Error as _serde::de::Error>::missing_field(
2276 "clutchDelayCountdown",
2277 ),
2278 );
2279 #[cfg(not(feature = "strict"))] Default::default()
2280 }
2281 };
2282 let __ptr = None;
2283 let parent = hkBaseObject { __ptr };
2284 let parent = hkReferencedObject {
2285 __ptr,
2286 parent,
2287 ..Default::default()
2288 };
2289 let parent = hkpAction {
2290 __ptr,
2291 parent,
2292 m_userData,
2293 m_name,
2294 ..Default::default()
2295 };
2296 let parent = hkpUnaryAction {
2297 __ptr,
2298 parent,
2299 m_entity,
2300 };
2301 let __ptr = __A::class_ptr(&mut __map);
2302 _serde::__private::Ok(hkpVehicleInstance {
2303 __ptr,
2304 parent,
2305 m_data,
2306 m_driverInput,
2307 m_steering,
2308 m_engine,
2309 m_transmission,
2310 m_brake,
2311 m_suspension,
2312 m_aerodynamics,
2313 m_wheelCollide,
2314 m_tyreMarks,
2315 m_velocityDamper,
2316 m_wheelsInfo,
2317 m_frictionStatus,
2318 m_deviceStatus,
2319 m_isFixed,
2320 m_wheelsTimeSinceMaxPedalInput,
2321 m_tryingToReverse,
2322 m_torque,
2323 m_rpm,
2324 m_mainSteeringAngle,
2325 m_wheelsSteeringAngle,
2326 m_isReversing,
2327 m_currentGear,
2328 m_delayed,
2329 m_clutchDelayCountdown,
2330 })
2331 }
2332 }
2333 const FIELDS: &[&str] = &[
2334 "data",
2335 "driverInput",
2336 "steering",
2337 "engine",
2338 "transmission",
2339 "brake",
2340 "suspension",
2341 "aerodynamics",
2342 "wheelCollide",
2343 "tyreMarks",
2344 "velocityDamper",
2345 "wheelsInfo",
2346 "frictionStatus",
2347 "deviceStatus",
2348 "isFixed",
2349 "wheelsTimeSinceMaxPedalInput",
2350 "tryingToReverse",
2351 "torque",
2352 "rpm",
2353 "mainSteeringAngle",
2354 "wheelsSteeringAngle",
2355 "isReversing",
2356 "currentGear",
2357 "delayed",
2358 "clutchDelayCountdown",
2359 ];
2360 _serde::Deserializer::deserialize_struct(
2361 deserializer,
2362 "hkpVehicleInstance",
2363 FIELDS,
2364 __hkpVehicleInstanceVisitor {
2365 marker: _serde::__private::PhantomData::<hkpVehicleInstance>,
2366 lifetime: _serde::__private::PhantomData,
2367 },
2368 )
2369 }
2370 }
2371};