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 hkpVehicleData {
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 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "gravity"))]
35 #[cfg_attr(feature = "serde", serde(rename = "gravity"))]
36 pub m_gravity: Vector4,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "numWheels"))]
42 #[cfg_attr(feature = "serde", serde(rename = "numWheels"))]
43 pub m_numWheels: i8,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "chassisOrientation"))]
49 #[cfg_attr(feature = "serde", serde(rename = "chassisOrientation"))]
50 pub m_chassisOrientation: Rotation,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "torqueRollFactor"))]
56 #[cfg_attr(feature = "serde", serde(rename = "torqueRollFactor"))]
57 pub m_torqueRollFactor: f32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "torquePitchFactor"))]
63 #[cfg_attr(feature = "serde", serde(rename = "torquePitchFactor"))]
64 pub m_torquePitchFactor: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "torqueYawFactor"))]
70 #[cfg_attr(feature = "serde", serde(rename = "torqueYawFactor"))]
71 pub m_torqueYawFactor: f32,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "extraTorqueFactor"))]
77 #[cfg_attr(feature = "serde", serde(rename = "extraTorqueFactor"))]
78 pub m_extraTorqueFactor: f32,
79 #[cfg_attr(
84 feature = "json_schema",
85 schemars(rename = "maxVelocityForPositionalFriction")
86 )]
87 #[cfg_attr(feature = "serde", serde(rename = "maxVelocityForPositionalFriction"))]
88 pub m_maxVelocityForPositionalFriction: f32,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "chassisUnitInertiaYaw"))]
94 #[cfg_attr(feature = "serde", serde(rename = "chassisUnitInertiaYaw"))]
95 pub m_chassisUnitInertiaYaw: f32,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "chassisUnitInertiaRoll"))]
101 #[cfg_attr(feature = "serde", serde(rename = "chassisUnitInertiaRoll"))]
102 pub m_chassisUnitInertiaRoll: f32,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "chassisUnitInertiaPitch"))]
108 #[cfg_attr(feature = "serde", serde(rename = "chassisUnitInertiaPitch"))]
109 pub m_chassisUnitInertiaPitch: f32,
110 #[cfg_attr(feature = "json_schema", schemars(rename = "frictionEqualizer"))]
115 #[cfg_attr(feature = "serde", serde(rename = "frictionEqualizer"))]
116 pub m_frictionEqualizer: f32,
117 #[cfg_attr(feature = "json_schema", schemars(rename = "normalClippingAngleCos"))]
122 #[cfg_attr(feature = "serde", serde(rename = "normalClippingAngleCos"))]
123 pub m_normalClippingAngleCos: f32,
124 #[cfg_attr(feature = "json_schema", schemars(rename = "maxFrictionSolverMassRatio"))]
129 #[cfg_attr(feature = "serde", serde(rename = "maxFrictionSolverMassRatio"))]
130 pub m_maxFrictionSolverMassRatio: f32,
131 #[cfg_attr(feature = "json_schema", schemars(rename = "wheelParams"))]
136 #[cfg_attr(feature = "serde", serde(rename = "wheelParams"))]
137 pub m_wheelParams: Vec<hkpVehicleDataWheelComponentParams>,
138 #[cfg_attr(feature = "json_schema", schemars(rename = "numWheelsPerAxle"))]
143 #[cfg_attr(feature = "serde", serde(rename = "numWheelsPerAxle"))]
144 pub m_numWheelsPerAxle: Vec<i8>,
145 #[cfg_attr(feature = "json_schema", schemars(rename = "frictionDescription"))]
150 #[cfg_attr(feature = "serde", serde(rename = "frictionDescription"))]
151 pub m_frictionDescription: hkpVehicleFrictionDescription,
152 #[cfg_attr(
157 feature = "json_schema",
158 schemars(rename = "chassisFrictionInertiaInvDiag")
159 )]
160 #[cfg_attr(feature = "serde", serde(rename = "chassisFrictionInertiaInvDiag"))]
161 pub m_chassisFrictionInertiaInvDiag: Vector4,
162 #[cfg_attr(feature = "json_schema", schemars(rename = "alreadyInitialised"))]
167 #[cfg_attr(feature = "serde", serde(rename = "alreadyInitialised"))]
168 pub m_alreadyInitialised: bool,
169}
170const _: () = {
171 use havok_serde as _serde;
172 impl _serde::HavokClass for hkpVehicleData {
173 #[inline]
174 fn name(&self) -> &'static str {
175 "hkpVehicleData"
176 }
177 #[inline]
178 fn signature(&self) -> _serde::__private::Signature {
179 _serde::__private::Signature::new(0x173feb43)
180 }
181 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
182 fn deps_indexes(&self) -> Vec<usize> {
183 let mut v = Vec::new();
184 v.extend(
185 self
186 .m_wheelParams
187 .iter()
188 .flat_map(|class| class.deps_indexes())
189 .collect::<Vec<usize>>(),
190 );
191 v.extend(self.m_frictionDescription.deps_indexes());
192 v
193 }
194 }
195 impl _serde::Serialize for hkpVehicleData {
196 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
197 where
198 S: _serde::ser::Serializer,
199 {
200 let class_meta = self
201 .__ptr
202 .map(|name| (name, _serde::__private::Signature::new(0x173feb43)));
203 let mut serializer = __serializer
204 .serialize_struct("hkpVehicleData", class_meta, (416u64, 416u64))?;
205 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
206 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
207 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
208 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
209 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
210 serializer.serialize_field("gravity", &self.m_gravity)?;
211 serializer.serialize_field("numWheels", &self.m_numWheels)?;
212 serializer.pad_field([0u8; 15usize].as_slice(), [0u8; 15usize].as_slice())?;
213 serializer
214 .serialize_field("chassisOrientation", &self.m_chassisOrientation)?;
215 serializer.serialize_field("torqueRollFactor", &self.m_torqueRollFactor)?;
216 serializer.serialize_field("torquePitchFactor", &self.m_torquePitchFactor)?;
217 serializer.serialize_field("torqueYawFactor", &self.m_torqueYawFactor)?;
218 serializer.serialize_field("extraTorqueFactor", &self.m_extraTorqueFactor)?;
219 serializer
220 .serialize_field(
221 "maxVelocityForPositionalFriction",
222 &self.m_maxVelocityForPositionalFriction,
223 )?;
224 serializer
225 .serialize_field(
226 "chassisUnitInertiaYaw",
227 &self.m_chassisUnitInertiaYaw,
228 )?;
229 serializer
230 .serialize_field(
231 "chassisUnitInertiaRoll",
232 &self.m_chassisUnitInertiaRoll,
233 )?;
234 serializer
235 .serialize_field(
236 "chassisUnitInertiaPitch",
237 &self.m_chassisUnitInertiaPitch,
238 )?;
239 serializer.serialize_field("frictionEqualizer", &self.m_frictionEqualizer)?;
240 serializer
241 .serialize_field(
242 "normalClippingAngleCos",
243 &self.m_normalClippingAngleCos,
244 )?;
245 serializer
246 .serialize_field(
247 "maxFrictionSolverMassRatio",
248 &self.m_maxFrictionSolverMassRatio,
249 )?;
250 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
251 serializer
252 .serialize_array_field(
253 "wheelParams",
254 &self.m_wheelParams,
255 TypeSize::Struct {
256 size_x86: 40u64,
257 size_x86_64: 40u64,
258 },
259 )?;
260 serializer
261 .serialize_array_field(
262 "numWheelsPerAxle",
263 &self.m_numWheelsPerAxle,
264 TypeSize::NonPtr,
265 )?;
266 serializer
267 .serialize_field("frictionDescription", &self.m_frictionDescription)?;
268 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 0usize].as_slice())?;
269 serializer
270 .serialize_field(
271 "chassisFrictionInertiaInvDiag",
272 &self.m_chassisFrictionInertiaInvDiag,
273 )?;
274 serializer
275 .serialize_field("alreadyInitialised", &self.m_alreadyInitialised)?;
276 serializer.pad_field([0u8; 15usize].as_slice(), [0u8; 15usize].as_slice())?;
277 serializer.end()
278 }
279 }
280};
281#[doc(hidden)]
282#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
283const _: () = {
284 use havok_serde as _serde;
285 #[automatically_derived]
286 impl<'de> _serde::Deserialize<'de> for hkpVehicleData {
287 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
288 where
289 __D: _serde::Deserializer<'de>,
290 {
291 #[allow(non_camel_case_types)]
292 enum __Field {
293 m_gravity,
294 m_numWheels,
295 m_chassisOrientation,
296 m_torqueRollFactor,
297 m_torquePitchFactor,
298 m_torqueYawFactor,
299 m_extraTorqueFactor,
300 m_maxVelocityForPositionalFriction,
301 m_chassisUnitInertiaYaw,
302 m_chassisUnitInertiaRoll,
303 m_chassisUnitInertiaPitch,
304 m_frictionEqualizer,
305 m_normalClippingAngleCos,
306 m_maxFrictionSolverMassRatio,
307 m_wheelParams,
308 m_numWheelsPerAxle,
309 m_frictionDescription,
310 m_chassisFrictionInertiaInvDiag,
311 m_alreadyInitialised,
312 __ignore,
313 }
314 struct __FieldVisitor;
315 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
316 type Value = __Field;
317 fn expecting(
318 &self,
319 __formatter: &mut core::fmt::Formatter,
320 ) -> core::fmt::Result {
321 core::fmt::Formatter::write_str(__formatter, "field identifier")
322 }
323 #[allow(clippy::match_single_binding)]
325 #[allow(clippy::reversed_empty_ranges)]
326 #[allow(clippy::single_match)]
327 fn visit_key<__E>(
328 self,
329 __value: &str,
330 ) -> core::result::Result<Self::Value, __E>
331 where
332 __E: _serde::de::Error,
333 {
334 match __value {
335 "gravity" => Ok(__Field::m_gravity),
336 "numWheels" => Ok(__Field::m_numWheels),
337 "chassisOrientation" => Ok(__Field::m_chassisOrientation),
338 "torqueRollFactor" => Ok(__Field::m_torqueRollFactor),
339 "torquePitchFactor" => Ok(__Field::m_torquePitchFactor),
340 "torqueYawFactor" => Ok(__Field::m_torqueYawFactor),
341 "extraTorqueFactor" => Ok(__Field::m_extraTorqueFactor),
342 "maxVelocityForPositionalFriction" => {
343 Ok(__Field::m_maxVelocityForPositionalFriction)
344 }
345 "chassisUnitInertiaYaw" => Ok(__Field::m_chassisUnitInertiaYaw),
346 "chassisUnitInertiaRoll" => Ok(__Field::m_chassisUnitInertiaRoll),
347 "chassisUnitInertiaPitch" => {
348 Ok(__Field::m_chassisUnitInertiaPitch)
349 }
350 "frictionEqualizer" => Ok(__Field::m_frictionEqualizer),
351 "normalClippingAngleCos" => Ok(__Field::m_normalClippingAngleCos),
352 "maxFrictionSolverMassRatio" => {
353 Ok(__Field::m_maxFrictionSolverMassRatio)
354 }
355 "wheelParams" => Ok(__Field::m_wheelParams),
356 "numWheelsPerAxle" => Ok(__Field::m_numWheelsPerAxle),
357 "frictionDescription" => Ok(__Field::m_frictionDescription),
358 "chassisFrictionInertiaInvDiag" => {
359 Ok(__Field::m_chassisFrictionInertiaInvDiag)
360 }
361 "alreadyInitialised" => Ok(__Field::m_alreadyInitialised),
362 _ => Ok(__Field::__ignore),
363 }
364 }
365 }
366 impl<'de> _serde::Deserialize<'de> for __Field {
367 #[inline]
368 fn deserialize<__D>(
369 __deserializer: __D,
370 ) -> core::result::Result<Self, __D::Error>
371 where
372 __D: _serde::Deserializer<'de>,
373 {
374 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
375 }
376 }
377 struct __hkpVehicleDataVisitor<'de> {
378 marker: _serde::__private::PhantomData<hkpVehicleData>,
379 lifetime: _serde::__private::PhantomData<&'de ()>,
380 }
381 #[allow(clippy::match_single_binding)]
382 #[allow(clippy::reversed_empty_ranges)]
383 #[allow(clippy::single_match)]
384 impl<'de> _serde::de::Visitor<'de> for __hkpVehicleDataVisitor<'de> {
385 type Value = hkpVehicleData;
386 fn expecting(
387 &self,
388 __formatter: &mut core::fmt::Formatter,
389 ) -> core::fmt::Result {
390 core::fmt::Formatter::write_str(__formatter, "struct hkpVehicleData")
391 }
392 fn visit_struct_for_bytes<__A>(
393 self,
394 mut __map: __A,
395 ) -> _serde::__private::Result<Self::Value, __A::Error>
396 where
397 __A: _serde::de::MapAccess<'de>,
398 {
399 let __ptr = __A::class_ptr(&mut __map);
400 let parent = __A::parent_value(&mut __map)?;
401 let mut m_gravity: _serde::__private::Option<Vector4> = _serde::__private::None;
402 let mut m_numWheels: _serde::__private::Option<i8> = _serde::__private::None;
403 let mut m_chassisOrientation: _serde::__private::Option<Rotation> = _serde::__private::None;
404 let mut m_torqueRollFactor: _serde::__private::Option<f32> = _serde::__private::None;
405 let mut m_torquePitchFactor: _serde::__private::Option<f32> = _serde::__private::None;
406 let mut m_torqueYawFactor: _serde::__private::Option<f32> = _serde::__private::None;
407 let mut m_extraTorqueFactor: _serde::__private::Option<f32> = _serde::__private::None;
408 let mut m_maxVelocityForPositionalFriction: _serde::__private::Option<
409 f32,
410 > = _serde::__private::None;
411 let mut m_chassisUnitInertiaYaw: _serde::__private::Option<f32> = _serde::__private::None;
412 let mut m_chassisUnitInertiaRoll: _serde::__private::Option<f32> = _serde::__private::None;
413 let mut m_chassisUnitInertiaPitch: _serde::__private::Option<f32> = _serde::__private::None;
414 let mut m_frictionEqualizer: _serde::__private::Option<f32> = _serde::__private::None;
415 let mut m_normalClippingAngleCos: _serde::__private::Option<f32> = _serde::__private::None;
416 let mut m_maxFrictionSolverMassRatio: _serde::__private::Option<
417 f32,
418 > = _serde::__private::None;
419 let mut m_wheelParams: _serde::__private::Option<
420 Vec<hkpVehicleDataWheelComponentParams>,
421 > = _serde::__private::None;
422 let mut m_numWheelsPerAxle: _serde::__private::Option<Vec<i8>> = _serde::__private::None;
423 let mut m_frictionDescription: _serde::__private::Option<
424 hkpVehicleFrictionDescription,
425 > = _serde::__private::None;
426 let mut m_chassisFrictionInertiaInvDiag: _serde::__private::Option<
427 Vector4,
428 > = _serde::__private::None;
429 let mut m_alreadyInitialised: _serde::__private::Option<bool> = _serde::__private::None;
430 for i in 0..19usize {
431 match i {
432 0usize => {
433 if _serde::__private::Option::is_some(&m_gravity) {
434 return _serde::__private::Err(
435 <__A::Error as _serde::de::Error>::duplicate_field(
436 "gravity",
437 ),
438 );
439 }
440 __A::pad(&mut __map, 8usize, 0usize)?;
441 m_gravity = _serde::__private::Some(
442 match __A::next_value::<Vector4>(&mut __map) {
443 _serde::__private::Ok(__val) => __val,
444 _serde::__private::Err(__err) => {
445 return _serde::__private::Err(__err);
446 }
447 },
448 );
449 }
450 1usize => {
451 if _serde::__private::Option::is_some(&m_numWheels) {
452 return _serde::__private::Err(
453 <__A::Error as _serde::de::Error>::duplicate_field(
454 "numWheels",
455 ),
456 );
457 }
458 m_numWheels = _serde::__private::Some(
459 match __A::next_value::<i8>(&mut __map) {
460 _serde::__private::Ok(__val) => __val,
461 _serde::__private::Err(__err) => {
462 return _serde::__private::Err(__err);
463 }
464 },
465 );
466 }
467 2usize => {
468 if _serde::__private::Option::is_some(
469 &m_chassisOrientation,
470 ) {
471 return _serde::__private::Err(
472 <__A::Error as _serde::de::Error>::duplicate_field(
473 "chassisOrientation",
474 ),
475 );
476 }
477 __A::pad(&mut __map, 15usize, 15usize)?;
478 m_chassisOrientation = _serde::__private::Some(
479 match __A::next_value::<Rotation>(&mut __map) {
480 _serde::__private::Ok(__val) => __val,
481 _serde::__private::Err(__err) => {
482 return _serde::__private::Err(__err);
483 }
484 },
485 );
486 }
487 3usize => {
488 if _serde::__private::Option::is_some(&m_torqueRollFactor) {
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::duplicate_field(
491 "torqueRollFactor",
492 ),
493 );
494 }
495 m_torqueRollFactor = _serde::__private::Some(
496 match __A::next_value::<f32>(&mut __map) {
497 _serde::__private::Ok(__val) => __val,
498 _serde::__private::Err(__err) => {
499 return _serde::__private::Err(__err);
500 }
501 },
502 );
503 }
504 4usize => {
505 if _serde::__private::Option::is_some(
506 &m_torquePitchFactor,
507 ) {
508 return _serde::__private::Err(
509 <__A::Error as _serde::de::Error>::duplicate_field(
510 "torquePitchFactor",
511 ),
512 );
513 }
514 m_torquePitchFactor = _serde::__private::Some(
515 match __A::next_value::<f32>(&mut __map) {
516 _serde::__private::Ok(__val) => __val,
517 _serde::__private::Err(__err) => {
518 return _serde::__private::Err(__err);
519 }
520 },
521 );
522 }
523 5usize => {
524 if _serde::__private::Option::is_some(&m_torqueYawFactor) {
525 return _serde::__private::Err(
526 <__A::Error as _serde::de::Error>::duplicate_field(
527 "torqueYawFactor",
528 ),
529 );
530 }
531 m_torqueYawFactor = _serde::__private::Some(
532 match __A::next_value::<f32>(&mut __map) {
533 _serde::__private::Ok(__val) => __val,
534 _serde::__private::Err(__err) => {
535 return _serde::__private::Err(__err);
536 }
537 },
538 );
539 }
540 6usize => {
541 if _serde::__private::Option::is_some(
542 &m_extraTorqueFactor,
543 ) {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::duplicate_field(
546 "extraTorqueFactor",
547 ),
548 );
549 }
550 m_extraTorqueFactor = _serde::__private::Some(
551 match __A::next_value::<f32>(&mut __map) {
552 _serde::__private::Ok(__val) => __val,
553 _serde::__private::Err(__err) => {
554 return _serde::__private::Err(__err);
555 }
556 },
557 );
558 }
559 7usize => {
560 if _serde::__private::Option::is_some(
561 &m_maxVelocityForPositionalFriction,
562 ) {
563 return _serde::__private::Err(
564 <__A::Error as _serde::de::Error>::duplicate_field(
565 "maxVelocityForPositionalFriction",
566 ),
567 );
568 }
569 m_maxVelocityForPositionalFriction = _serde::__private::Some(
570 match __A::next_value::<f32>(&mut __map) {
571 _serde::__private::Ok(__val) => __val,
572 _serde::__private::Err(__err) => {
573 return _serde::__private::Err(__err);
574 }
575 },
576 );
577 }
578 8usize => {
579 if _serde::__private::Option::is_some(
580 &m_chassisUnitInertiaYaw,
581 ) {
582 return _serde::__private::Err(
583 <__A::Error as _serde::de::Error>::duplicate_field(
584 "chassisUnitInertiaYaw",
585 ),
586 );
587 }
588 m_chassisUnitInertiaYaw = _serde::__private::Some(
589 match __A::next_value::<f32>(&mut __map) {
590 _serde::__private::Ok(__val) => __val,
591 _serde::__private::Err(__err) => {
592 return _serde::__private::Err(__err);
593 }
594 },
595 );
596 }
597 9usize => {
598 if _serde::__private::Option::is_some(
599 &m_chassisUnitInertiaRoll,
600 ) {
601 return _serde::__private::Err(
602 <__A::Error as _serde::de::Error>::duplicate_field(
603 "chassisUnitInertiaRoll",
604 ),
605 );
606 }
607 m_chassisUnitInertiaRoll = _serde::__private::Some(
608 match __A::next_value::<f32>(&mut __map) {
609 _serde::__private::Ok(__val) => __val,
610 _serde::__private::Err(__err) => {
611 return _serde::__private::Err(__err);
612 }
613 },
614 );
615 }
616 10usize => {
617 if _serde::__private::Option::is_some(
618 &m_chassisUnitInertiaPitch,
619 ) {
620 return _serde::__private::Err(
621 <__A::Error as _serde::de::Error>::duplicate_field(
622 "chassisUnitInertiaPitch",
623 ),
624 );
625 }
626 m_chassisUnitInertiaPitch = _serde::__private::Some(
627 match __A::next_value::<f32>(&mut __map) {
628 _serde::__private::Ok(__val) => __val,
629 _serde::__private::Err(__err) => {
630 return _serde::__private::Err(__err);
631 }
632 },
633 );
634 }
635 11usize => {
636 if _serde::__private::Option::is_some(
637 &m_frictionEqualizer,
638 ) {
639 return _serde::__private::Err(
640 <__A::Error as _serde::de::Error>::duplicate_field(
641 "frictionEqualizer",
642 ),
643 );
644 }
645 m_frictionEqualizer = _serde::__private::Some(
646 match __A::next_value::<f32>(&mut __map) {
647 _serde::__private::Ok(__val) => __val,
648 _serde::__private::Err(__err) => {
649 return _serde::__private::Err(__err);
650 }
651 },
652 );
653 }
654 12usize => {
655 if _serde::__private::Option::is_some(
656 &m_normalClippingAngleCos,
657 ) {
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::duplicate_field(
660 "normalClippingAngleCos",
661 ),
662 );
663 }
664 m_normalClippingAngleCos = _serde::__private::Some(
665 match __A::next_value::<f32>(&mut __map) {
666 _serde::__private::Ok(__val) => __val,
667 _serde::__private::Err(__err) => {
668 return _serde::__private::Err(__err);
669 }
670 },
671 );
672 }
673 13usize => {
674 if _serde::__private::Option::is_some(
675 &m_maxFrictionSolverMassRatio,
676 ) {
677 return _serde::__private::Err(
678 <__A::Error as _serde::de::Error>::duplicate_field(
679 "maxFrictionSolverMassRatio",
680 ),
681 );
682 }
683 m_maxFrictionSolverMassRatio = _serde::__private::Some(
684 match __A::next_value::<f32>(&mut __map) {
685 _serde::__private::Ok(__val) => __val,
686 _serde::__private::Err(__err) => {
687 return _serde::__private::Err(__err);
688 }
689 },
690 );
691 }
692 14usize => {
693 if _serde::__private::Option::is_some(&m_wheelParams) {
694 return _serde::__private::Err(
695 <__A::Error as _serde::de::Error>::duplicate_field(
696 "wheelParams",
697 ),
698 );
699 }
700 __A::pad(&mut __map, 0usize, 4usize)?;
701 m_wheelParams = _serde::__private::Some(
702 match __A::next_value::<
703 Vec<hkpVehicleDataWheelComponentParams>,
704 >(&mut __map) {
705 _serde::__private::Ok(__val) => __val,
706 _serde::__private::Err(__err) => {
707 return _serde::__private::Err(__err);
708 }
709 },
710 );
711 }
712 15usize => {
713 if _serde::__private::Option::is_some(&m_numWheelsPerAxle) {
714 return _serde::__private::Err(
715 <__A::Error as _serde::de::Error>::duplicate_field(
716 "numWheelsPerAxle",
717 ),
718 );
719 }
720 m_numWheelsPerAxle = _serde::__private::Some(
721 match __A::next_value::<Vec<i8>>(&mut __map) {
722 _serde::__private::Ok(__val) => __val,
723 _serde::__private::Err(__err) => {
724 return _serde::__private::Err(__err);
725 }
726 },
727 );
728 }
729 16usize => {
730 if _serde::__private::Option::is_some(
731 &m_frictionDescription,
732 ) {
733 return _serde::__private::Err(
734 <__A::Error as _serde::de::Error>::duplicate_field(
735 "frictionDescription",
736 ),
737 );
738 }
739 m_frictionDescription = _serde::__private::Some(
740 match __A::next_value::<
741 hkpVehicleFrictionDescription,
742 >(&mut __map) {
743 _serde::__private::Ok(__val) => __val,
744 _serde::__private::Err(__err) => {
745 return _serde::__private::Err(__err);
746 }
747 },
748 );
749 }
750 17usize => {
751 if _serde::__private::Option::is_some(
752 &m_chassisFrictionInertiaInvDiag,
753 ) {
754 return _serde::__private::Err(
755 <__A::Error as _serde::de::Error>::duplicate_field(
756 "chassisFrictionInertiaInvDiag",
757 ),
758 );
759 }
760 __A::pad(&mut __map, 12usize, 0usize)?;
761 m_chassisFrictionInertiaInvDiag = _serde::__private::Some(
762 match __A::next_value::<Vector4>(&mut __map) {
763 _serde::__private::Ok(__val) => __val,
764 _serde::__private::Err(__err) => {
765 return _serde::__private::Err(__err);
766 }
767 },
768 );
769 }
770 18usize => {
771 if _serde::__private::Option::is_some(
772 &m_alreadyInitialised,
773 ) {
774 return _serde::__private::Err(
775 <__A::Error as _serde::de::Error>::duplicate_field(
776 "alreadyInitialised",
777 ),
778 );
779 }
780 m_alreadyInitialised = _serde::__private::Some(
781 match __A::next_value::<bool>(&mut __map) {
782 _serde::__private::Ok(__val) => __val,
783 _serde::__private::Err(__err) => {
784 return _serde::__private::Err(__err);
785 }
786 },
787 );
788 }
789 _ => {}
790 }
791 }
792 __A::pad(&mut __map, 15usize, 15usize)?;
793 let m_gravity = match m_gravity {
794 _serde::__private::Some(__field) => __field,
795 _serde::__private::None => {
796 return _serde::__private::Err(
797 <__A::Error as _serde::de::Error>::missing_field("gravity"),
798 );
799 }
800 };
801 let m_numWheels = match m_numWheels {
802 _serde::__private::Some(__field) => __field,
803 _serde::__private::None => {
804 return _serde::__private::Err(
805 <__A::Error as _serde::de::Error>::missing_field(
806 "numWheels",
807 ),
808 );
809 }
810 };
811 let m_chassisOrientation = match m_chassisOrientation {
812 _serde::__private::Some(__field) => __field,
813 _serde::__private::None => {
814 return _serde::__private::Err(
815 <__A::Error as _serde::de::Error>::missing_field(
816 "chassisOrientation",
817 ),
818 );
819 }
820 };
821 let m_torqueRollFactor = match m_torqueRollFactor {
822 _serde::__private::Some(__field) => __field,
823 _serde::__private::None => {
824 return _serde::__private::Err(
825 <__A::Error as _serde::de::Error>::missing_field(
826 "torqueRollFactor",
827 ),
828 );
829 }
830 };
831 let m_torquePitchFactor = match m_torquePitchFactor {
832 _serde::__private::Some(__field) => __field,
833 _serde::__private::None => {
834 return _serde::__private::Err(
835 <__A::Error as _serde::de::Error>::missing_field(
836 "torquePitchFactor",
837 ),
838 );
839 }
840 };
841 let m_torqueYawFactor = match m_torqueYawFactor {
842 _serde::__private::Some(__field) => __field,
843 _serde::__private::None => {
844 return _serde::__private::Err(
845 <__A::Error as _serde::de::Error>::missing_field(
846 "torqueYawFactor",
847 ),
848 );
849 }
850 };
851 let m_extraTorqueFactor = match m_extraTorqueFactor {
852 _serde::__private::Some(__field) => __field,
853 _serde::__private::None => {
854 return _serde::__private::Err(
855 <__A::Error as _serde::de::Error>::missing_field(
856 "extraTorqueFactor",
857 ),
858 );
859 }
860 };
861 let m_maxVelocityForPositionalFriction = match m_maxVelocityForPositionalFriction {
862 _serde::__private::Some(__field) => __field,
863 _serde::__private::None => {
864 return _serde::__private::Err(
865 <__A::Error as _serde::de::Error>::missing_field(
866 "maxVelocityForPositionalFriction",
867 ),
868 );
869 }
870 };
871 let m_chassisUnitInertiaYaw = match m_chassisUnitInertiaYaw {
872 _serde::__private::Some(__field) => __field,
873 _serde::__private::None => {
874 return _serde::__private::Err(
875 <__A::Error as _serde::de::Error>::missing_field(
876 "chassisUnitInertiaYaw",
877 ),
878 );
879 }
880 };
881 let m_chassisUnitInertiaRoll = match m_chassisUnitInertiaRoll {
882 _serde::__private::Some(__field) => __field,
883 _serde::__private::None => {
884 return _serde::__private::Err(
885 <__A::Error as _serde::de::Error>::missing_field(
886 "chassisUnitInertiaRoll",
887 ),
888 );
889 }
890 };
891 let m_chassisUnitInertiaPitch = match m_chassisUnitInertiaPitch {
892 _serde::__private::Some(__field) => __field,
893 _serde::__private::None => {
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::missing_field(
896 "chassisUnitInertiaPitch",
897 ),
898 );
899 }
900 };
901 let m_frictionEqualizer = match m_frictionEqualizer {
902 _serde::__private::Some(__field) => __field,
903 _serde::__private::None => {
904 return _serde::__private::Err(
905 <__A::Error as _serde::de::Error>::missing_field(
906 "frictionEqualizer",
907 ),
908 );
909 }
910 };
911 let m_normalClippingAngleCos = match m_normalClippingAngleCos {
912 _serde::__private::Some(__field) => __field,
913 _serde::__private::None => {
914 return _serde::__private::Err(
915 <__A::Error as _serde::de::Error>::missing_field(
916 "normalClippingAngleCos",
917 ),
918 );
919 }
920 };
921 let m_maxFrictionSolverMassRatio = match m_maxFrictionSolverMassRatio {
922 _serde::__private::Some(__field) => __field,
923 _serde::__private::None => {
924 return _serde::__private::Err(
925 <__A::Error as _serde::de::Error>::missing_field(
926 "maxFrictionSolverMassRatio",
927 ),
928 );
929 }
930 };
931 let m_wheelParams = match m_wheelParams {
932 _serde::__private::Some(__field) => __field,
933 _serde::__private::None => {
934 return _serde::__private::Err(
935 <__A::Error as _serde::de::Error>::missing_field(
936 "wheelParams",
937 ),
938 );
939 }
940 };
941 let m_numWheelsPerAxle = match m_numWheelsPerAxle {
942 _serde::__private::Some(__field) => __field,
943 _serde::__private::None => {
944 return _serde::__private::Err(
945 <__A::Error as _serde::de::Error>::missing_field(
946 "numWheelsPerAxle",
947 ),
948 );
949 }
950 };
951 let m_frictionDescription = match m_frictionDescription {
952 _serde::__private::Some(__field) => __field,
953 _serde::__private::None => {
954 return _serde::__private::Err(
955 <__A::Error as _serde::de::Error>::missing_field(
956 "frictionDescription",
957 ),
958 );
959 }
960 };
961 let m_chassisFrictionInertiaInvDiag = match m_chassisFrictionInertiaInvDiag {
962 _serde::__private::Some(__field) => __field,
963 _serde::__private::None => {
964 return _serde::__private::Err(
965 <__A::Error as _serde::de::Error>::missing_field(
966 "chassisFrictionInertiaInvDiag",
967 ),
968 );
969 }
970 };
971 let m_alreadyInitialised = match m_alreadyInitialised {
972 _serde::__private::Some(__field) => __field,
973 _serde::__private::None => {
974 return _serde::__private::Err(
975 <__A::Error as _serde::de::Error>::missing_field(
976 "alreadyInitialised",
977 ),
978 );
979 }
980 };
981 _serde::__private::Ok(hkpVehicleData {
982 __ptr,
983 parent,
984 m_gravity,
985 m_numWheels,
986 m_chassisOrientation,
987 m_torqueRollFactor,
988 m_torquePitchFactor,
989 m_torqueYawFactor,
990 m_extraTorqueFactor,
991 m_maxVelocityForPositionalFriction,
992 m_chassisUnitInertiaYaw,
993 m_chassisUnitInertiaRoll,
994 m_chassisUnitInertiaPitch,
995 m_frictionEqualizer,
996 m_normalClippingAngleCos,
997 m_maxFrictionSolverMassRatio,
998 m_wheelParams,
999 m_numWheelsPerAxle,
1000 m_frictionDescription,
1001 m_chassisFrictionInertiaInvDiag,
1002 m_alreadyInitialised,
1003 })
1004 }
1005 #[allow(clippy::manual_unwrap_or_default)]
1006 fn visit_struct<__A>(
1007 self,
1008 mut __map: __A,
1009 ) -> _serde::__private::Result<Self::Value, __A::Error>
1010 where
1011 __A: _serde::de::MapAccess<'de>,
1012 {
1013 let mut m_gravity: _serde::__private::Option<Vector4> = _serde::__private::None;
1014 let mut m_numWheels: _serde::__private::Option<i8> = _serde::__private::None;
1015 let mut m_chassisOrientation: _serde::__private::Option<Rotation> = _serde::__private::None;
1016 let mut m_torqueRollFactor: _serde::__private::Option<f32> = _serde::__private::None;
1017 let mut m_torquePitchFactor: _serde::__private::Option<f32> = _serde::__private::None;
1018 let mut m_torqueYawFactor: _serde::__private::Option<f32> = _serde::__private::None;
1019 let mut m_extraTorqueFactor: _serde::__private::Option<f32> = _serde::__private::None;
1020 let mut m_maxVelocityForPositionalFriction: _serde::__private::Option<
1021 f32,
1022 > = _serde::__private::None;
1023 let mut m_chassisUnitInertiaYaw: _serde::__private::Option<f32> = _serde::__private::None;
1024 let mut m_chassisUnitInertiaRoll: _serde::__private::Option<f32> = _serde::__private::None;
1025 let mut m_chassisUnitInertiaPitch: _serde::__private::Option<f32> = _serde::__private::None;
1026 let mut m_frictionEqualizer: _serde::__private::Option<f32> = _serde::__private::None;
1027 let mut m_normalClippingAngleCos: _serde::__private::Option<f32> = _serde::__private::None;
1028 let mut m_maxFrictionSolverMassRatio: _serde::__private::Option<
1029 f32,
1030 > = _serde::__private::None;
1031 let mut m_wheelParams: _serde::__private::Option<
1032 Vec<hkpVehicleDataWheelComponentParams>,
1033 > = _serde::__private::None;
1034 let mut m_numWheelsPerAxle: _serde::__private::Option<Vec<i8>> = _serde::__private::None;
1035 let mut m_frictionDescription: _serde::__private::Option<
1036 hkpVehicleFrictionDescription,
1037 > = _serde::__private::None;
1038 let mut m_chassisFrictionInertiaInvDiag: _serde::__private::Option<
1039 Vector4,
1040 > = _serde::__private::None;
1041 let mut m_alreadyInitialised: _serde::__private::Option<bool> = _serde::__private::None;
1042 while let _serde::__private::Some(__key) = {
1043 __A::next_key::<__Field>(&mut __map)?
1044 } {
1045 match __key {
1046 __Field::m_gravity => {
1047 #[cfg(
1048 any(feature = "strict", feature = "ignore_duplicates")
1049 )]
1050 if _serde::__private::Option::is_some(&m_gravity) {
1051 #[cfg(feature = "ignore_duplicates")]
1052 {
1053 __A::skip_value(&mut __map)?;
1054 continue;
1055 }
1056 #[cfg(feature = "strict")]
1057 return _serde::__private::Err(
1058 <__A::Error as _serde::de::Error>::duplicate_field(
1059 "gravity",
1060 ),
1061 );
1062 }
1063 m_gravity = _serde::__private::Some(
1064 match __A::next_value::<Vector4>(&mut __map) {
1065 _serde::__private::Ok(__val) => __val,
1066 _serde::__private::Err(__err) => {
1067 return _serde::__private::Err(__err);
1068 }
1069 },
1070 );
1071 }
1072 __Field::m_numWheels => {
1073 #[cfg(
1074 any(feature = "strict", feature = "ignore_duplicates")
1075 )]
1076 if _serde::__private::Option::is_some(&m_numWheels) {
1077 #[cfg(feature = "ignore_duplicates")]
1078 {
1079 __A::skip_value(&mut __map)?;
1080 continue;
1081 }
1082 #[cfg(feature = "strict")]
1083 return _serde::__private::Err(
1084 <__A::Error as _serde::de::Error>::duplicate_field(
1085 "numWheels",
1086 ),
1087 );
1088 }
1089 m_numWheels = _serde::__private::Some(
1090 match __A::next_value::<i8>(&mut __map) {
1091 _serde::__private::Ok(__val) => __val,
1092 _serde::__private::Err(__err) => {
1093 return _serde::__private::Err(__err);
1094 }
1095 },
1096 );
1097 }
1098 __Field::m_chassisOrientation => {
1099 #[cfg(
1100 any(feature = "strict", feature = "ignore_duplicates")
1101 )]
1102 if _serde::__private::Option::is_some(
1103 &m_chassisOrientation,
1104 ) {
1105 #[cfg(feature = "ignore_duplicates")]
1106 {
1107 __A::skip_value(&mut __map)?;
1108 continue;
1109 }
1110 #[cfg(feature = "strict")]
1111 return _serde::__private::Err(
1112 <__A::Error as _serde::de::Error>::duplicate_field(
1113 "chassisOrientation",
1114 ),
1115 );
1116 }
1117 m_chassisOrientation = _serde::__private::Some(
1118 match __A::next_value::<Rotation>(&mut __map) {
1119 _serde::__private::Ok(__val) => __val,
1120 _serde::__private::Err(__err) => {
1121 return _serde::__private::Err(__err);
1122 }
1123 },
1124 );
1125 }
1126 __Field::m_torqueRollFactor => {
1127 #[cfg(
1128 any(feature = "strict", feature = "ignore_duplicates")
1129 )]
1130 if _serde::__private::Option::is_some(&m_torqueRollFactor) {
1131 #[cfg(feature = "ignore_duplicates")]
1132 {
1133 __A::skip_value(&mut __map)?;
1134 continue;
1135 }
1136 #[cfg(feature = "strict")]
1137 return _serde::__private::Err(
1138 <__A::Error as _serde::de::Error>::duplicate_field(
1139 "torqueRollFactor",
1140 ),
1141 );
1142 }
1143 m_torqueRollFactor = _serde::__private::Some(
1144 match __A::next_value::<f32>(&mut __map) {
1145 _serde::__private::Ok(__val) => __val,
1146 _serde::__private::Err(__err) => {
1147 return _serde::__private::Err(__err);
1148 }
1149 },
1150 );
1151 }
1152 __Field::m_torquePitchFactor => {
1153 #[cfg(
1154 any(feature = "strict", feature = "ignore_duplicates")
1155 )]
1156 if _serde::__private::Option::is_some(
1157 &m_torquePitchFactor,
1158 ) {
1159 #[cfg(feature = "ignore_duplicates")]
1160 {
1161 __A::skip_value(&mut __map)?;
1162 continue;
1163 }
1164 #[cfg(feature = "strict")]
1165 return _serde::__private::Err(
1166 <__A::Error as _serde::de::Error>::duplicate_field(
1167 "torquePitchFactor",
1168 ),
1169 );
1170 }
1171 m_torquePitchFactor = _serde::__private::Some(
1172 match __A::next_value::<f32>(&mut __map) {
1173 _serde::__private::Ok(__val) => __val,
1174 _serde::__private::Err(__err) => {
1175 return _serde::__private::Err(__err);
1176 }
1177 },
1178 );
1179 }
1180 __Field::m_torqueYawFactor => {
1181 #[cfg(
1182 any(feature = "strict", feature = "ignore_duplicates")
1183 )]
1184 if _serde::__private::Option::is_some(&m_torqueYawFactor) {
1185 #[cfg(feature = "ignore_duplicates")]
1186 {
1187 __A::skip_value(&mut __map)?;
1188 continue;
1189 }
1190 #[cfg(feature = "strict")]
1191 return _serde::__private::Err(
1192 <__A::Error as _serde::de::Error>::duplicate_field(
1193 "torqueYawFactor",
1194 ),
1195 );
1196 }
1197 m_torqueYawFactor = _serde::__private::Some(
1198 match __A::next_value::<f32>(&mut __map) {
1199 _serde::__private::Ok(__val) => __val,
1200 _serde::__private::Err(__err) => {
1201 return _serde::__private::Err(__err);
1202 }
1203 },
1204 );
1205 }
1206 __Field::m_extraTorqueFactor => {
1207 #[cfg(
1208 any(feature = "strict", feature = "ignore_duplicates")
1209 )]
1210 if _serde::__private::Option::is_some(
1211 &m_extraTorqueFactor,
1212 ) {
1213 #[cfg(feature = "ignore_duplicates")]
1214 {
1215 __A::skip_value(&mut __map)?;
1216 continue;
1217 }
1218 #[cfg(feature = "strict")]
1219 return _serde::__private::Err(
1220 <__A::Error as _serde::de::Error>::duplicate_field(
1221 "extraTorqueFactor",
1222 ),
1223 );
1224 }
1225 m_extraTorqueFactor = _serde::__private::Some(
1226 match __A::next_value::<f32>(&mut __map) {
1227 _serde::__private::Ok(__val) => __val,
1228 _serde::__private::Err(__err) => {
1229 return _serde::__private::Err(__err);
1230 }
1231 },
1232 );
1233 }
1234 __Field::m_maxVelocityForPositionalFriction => {
1235 #[cfg(
1236 any(feature = "strict", feature = "ignore_duplicates")
1237 )]
1238 if _serde::__private::Option::is_some(
1239 &m_maxVelocityForPositionalFriction,
1240 ) {
1241 #[cfg(feature = "ignore_duplicates")]
1242 {
1243 __A::skip_value(&mut __map)?;
1244 continue;
1245 }
1246 #[cfg(feature = "strict")]
1247 return _serde::__private::Err(
1248 <__A::Error as _serde::de::Error>::duplicate_field(
1249 "maxVelocityForPositionalFriction",
1250 ),
1251 );
1252 }
1253 m_maxVelocityForPositionalFriction = _serde::__private::Some(
1254 match __A::next_value::<f32>(&mut __map) {
1255 _serde::__private::Ok(__val) => __val,
1256 _serde::__private::Err(__err) => {
1257 return _serde::__private::Err(__err);
1258 }
1259 },
1260 );
1261 }
1262 __Field::m_chassisUnitInertiaYaw => {
1263 #[cfg(
1264 any(feature = "strict", feature = "ignore_duplicates")
1265 )]
1266 if _serde::__private::Option::is_some(
1267 &m_chassisUnitInertiaYaw,
1268 ) {
1269 #[cfg(feature = "ignore_duplicates")]
1270 {
1271 __A::skip_value(&mut __map)?;
1272 continue;
1273 }
1274 #[cfg(feature = "strict")]
1275 return _serde::__private::Err(
1276 <__A::Error as _serde::de::Error>::duplicate_field(
1277 "chassisUnitInertiaYaw",
1278 ),
1279 );
1280 }
1281 m_chassisUnitInertiaYaw = _serde::__private::Some(
1282 match __A::next_value::<f32>(&mut __map) {
1283 _serde::__private::Ok(__val) => __val,
1284 _serde::__private::Err(__err) => {
1285 return _serde::__private::Err(__err);
1286 }
1287 },
1288 );
1289 }
1290 __Field::m_chassisUnitInertiaRoll => {
1291 #[cfg(
1292 any(feature = "strict", feature = "ignore_duplicates")
1293 )]
1294 if _serde::__private::Option::is_some(
1295 &m_chassisUnitInertiaRoll,
1296 ) {
1297 #[cfg(feature = "ignore_duplicates")]
1298 {
1299 __A::skip_value(&mut __map)?;
1300 continue;
1301 }
1302 #[cfg(feature = "strict")]
1303 return _serde::__private::Err(
1304 <__A::Error as _serde::de::Error>::duplicate_field(
1305 "chassisUnitInertiaRoll",
1306 ),
1307 );
1308 }
1309 m_chassisUnitInertiaRoll = _serde::__private::Some(
1310 match __A::next_value::<f32>(&mut __map) {
1311 _serde::__private::Ok(__val) => __val,
1312 _serde::__private::Err(__err) => {
1313 return _serde::__private::Err(__err);
1314 }
1315 },
1316 );
1317 }
1318 __Field::m_chassisUnitInertiaPitch => {
1319 #[cfg(
1320 any(feature = "strict", feature = "ignore_duplicates")
1321 )]
1322 if _serde::__private::Option::is_some(
1323 &m_chassisUnitInertiaPitch,
1324 ) {
1325 #[cfg(feature = "ignore_duplicates")]
1326 {
1327 __A::skip_value(&mut __map)?;
1328 continue;
1329 }
1330 #[cfg(feature = "strict")]
1331 return _serde::__private::Err(
1332 <__A::Error as _serde::de::Error>::duplicate_field(
1333 "chassisUnitInertiaPitch",
1334 ),
1335 );
1336 }
1337 m_chassisUnitInertiaPitch = _serde::__private::Some(
1338 match __A::next_value::<f32>(&mut __map) {
1339 _serde::__private::Ok(__val) => __val,
1340 _serde::__private::Err(__err) => {
1341 return _serde::__private::Err(__err);
1342 }
1343 },
1344 );
1345 }
1346 __Field::m_frictionEqualizer => {
1347 #[cfg(
1348 any(feature = "strict", feature = "ignore_duplicates")
1349 )]
1350 if _serde::__private::Option::is_some(
1351 &m_frictionEqualizer,
1352 ) {
1353 #[cfg(feature = "ignore_duplicates")]
1354 {
1355 __A::skip_value(&mut __map)?;
1356 continue;
1357 }
1358 #[cfg(feature = "strict")]
1359 return _serde::__private::Err(
1360 <__A::Error as _serde::de::Error>::duplicate_field(
1361 "frictionEqualizer",
1362 ),
1363 );
1364 }
1365 m_frictionEqualizer = _serde::__private::Some(
1366 match __A::next_value::<f32>(&mut __map) {
1367 _serde::__private::Ok(__val) => __val,
1368 _serde::__private::Err(__err) => {
1369 return _serde::__private::Err(__err);
1370 }
1371 },
1372 );
1373 }
1374 __Field::m_normalClippingAngleCos => {
1375 #[cfg(
1376 any(feature = "strict", feature = "ignore_duplicates")
1377 )]
1378 if _serde::__private::Option::is_some(
1379 &m_normalClippingAngleCos,
1380 ) {
1381 #[cfg(feature = "ignore_duplicates")]
1382 {
1383 __A::skip_value(&mut __map)?;
1384 continue;
1385 }
1386 #[cfg(feature = "strict")]
1387 return _serde::__private::Err(
1388 <__A::Error as _serde::de::Error>::duplicate_field(
1389 "normalClippingAngleCos",
1390 ),
1391 );
1392 }
1393 m_normalClippingAngleCos = _serde::__private::Some(
1394 match __A::next_value::<f32>(&mut __map) {
1395 _serde::__private::Ok(__val) => __val,
1396 _serde::__private::Err(__err) => {
1397 return _serde::__private::Err(__err);
1398 }
1399 },
1400 );
1401 }
1402 __Field::m_maxFrictionSolverMassRatio => {
1403 #[cfg(
1404 any(feature = "strict", feature = "ignore_duplicates")
1405 )]
1406 if _serde::__private::Option::is_some(
1407 &m_maxFrictionSolverMassRatio,
1408 ) {
1409 #[cfg(feature = "ignore_duplicates")]
1410 {
1411 __A::skip_value(&mut __map)?;
1412 continue;
1413 }
1414 #[cfg(feature = "strict")]
1415 return _serde::__private::Err(
1416 <__A::Error as _serde::de::Error>::duplicate_field(
1417 "maxFrictionSolverMassRatio",
1418 ),
1419 );
1420 }
1421 m_maxFrictionSolverMassRatio = _serde::__private::Some(
1422 match __A::next_value::<f32>(&mut __map) {
1423 _serde::__private::Ok(__val) => __val,
1424 _serde::__private::Err(__err) => {
1425 return _serde::__private::Err(__err);
1426 }
1427 },
1428 );
1429 }
1430 __Field::m_wheelParams => {
1431 #[cfg(
1432 any(feature = "strict", feature = "ignore_duplicates")
1433 )]
1434 if _serde::__private::Option::is_some(&m_wheelParams) {
1435 #[cfg(feature = "ignore_duplicates")]
1436 {
1437 __A::skip_value(&mut __map)?;
1438 continue;
1439 }
1440 #[cfg(feature = "strict")]
1441 return _serde::__private::Err(
1442 <__A::Error as _serde::de::Error>::duplicate_field(
1443 "wheelParams",
1444 ),
1445 );
1446 }
1447 m_wheelParams = _serde::__private::Some(
1448 match __A::next_value::<
1449 Vec<hkpVehicleDataWheelComponentParams>,
1450 >(&mut __map) {
1451 _serde::__private::Ok(__val) => __val,
1452 _serde::__private::Err(__err) => {
1453 return _serde::__private::Err(__err);
1454 }
1455 },
1456 );
1457 }
1458 __Field::m_numWheelsPerAxle => {
1459 #[cfg(
1460 any(feature = "strict", feature = "ignore_duplicates")
1461 )]
1462 if _serde::__private::Option::is_some(&m_numWheelsPerAxle) {
1463 #[cfg(feature = "ignore_duplicates")]
1464 {
1465 __A::skip_value(&mut __map)?;
1466 continue;
1467 }
1468 #[cfg(feature = "strict")]
1469 return _serde::__private::Err(
1470 <__A::Error as _serde::de::Error>::duplicate_field(
1471 "numWheelsPerAxle",
1472 ),
1473 );
1474 }
1475 m_numWheelsPerAxle = _serde::__private::Some(
1476 match __A::next_value::<Vec<i8>>(&mut __map) {
1477 _serde::__private::Ok(__val) => __val,
1478 _serde::__private::Err(__err) => {
1479 return _serde::__private::Err(__err);
1480 }
1481 },
1482 );
1483 }
1484 __Field::m_frictionDescription => {
1485 #[cfg(
1486 any(feature = "strict", feature = "ignore_duplicates")
1487 )]
1488 if _serde::__private::Option::is_some(
1489 &m_frictionDescription,
1490 ) {
1491 #[cfg(feature = "ignore_duplicates")]
1492 {
1493 __A::skip_value(&mut __map)?;
1494 continue;
1495 }
1496 #[cfg(feature = "strict")]
1497 return _serde::__private::Err(
1498 <__A::Error as _serde::de::Error>::duplicate_field(
1499 "frictionDescription",
1500 ),
1501 );
1502 }
1503 m_frictionDescription = _serde::__private::Some(
1504 match __A::next_value::<
1505 hkpVehicleFrictionDescription,
1506 >(&mut __map) {
1507 _serde::__private::Ok(__val) => __val,
1508 _serde::__private::Err(__err) => {
1509 return _serde::__private::Err(__err);
1510 }
1511 },
1512 );
1513 }
1514 __Field::m_chassisFrictionInertiaInvDiag => {
1515 #[cfg(
1516 any(feature = "strict", feature = "ignore_duplicates")
1517 )]
1518 if _serde::__private::Option::is_some(
1519 &m_chassisFrictionInertiaInvDiag,
1520 ) {
1521 #[cfg(feature = "ignore_duplicates")]
1522 {
1523 __A::skip_value(&mut __map)?;
1524 continue;
1525 }
1526 #[cfg(feature = "strict")]
1527 return _serde::__private::Err(
1528 <__A::Error as _serde::de::Error>::duplicate_field(
1529 "chassisFrictionInertiaInvDiag",
1530 ),
1531 );
1532 }
1533 m_chassisFrictionInertiaInvDiag = _serde::__private::Some(
1534 match __A::next_value::<Vector4>(&mut __map) {
1535 _serde::__private::Ok(__val) => __val,
1536 _serde::__private::Err(__err) => {
1537 return _serde::__private::Err(__err);
1538 }
1539 },
1540 );
1541 }
1542 __Field::m_alreadyInitialised => {
1543 #[cfg(
1544 any(feature = "strict", feature = "ignore_duplicates")
1545 )]
1546 if _serde::__private::Option::is_some(
1547 &m_alreadyInitialised,
1548 ) {
1549 #[cfg(feature = "ignore_duplicates")]
1550 {
1551 __A::skip_value(&mut __map)?;
1552 continue;
1553 }
1554 #[cfg(feature = "strict")]
1555 return _serde::__private::Err(
1556 <__A::Error as _serde::de::Error>::duplicate_field(
1557 "alreadyInitialised",
1558 ),
1559 );
1560 }
1561 m_alreadyInitialised = _serde::__private::Some(
1562 match __A::next_value::<bool>(&mut __map) {
1563 _serde::__private::Ok(__val) => __val,
1564 _serde::__private::Err(__err) => {
1565 return _serde::__private::Err(__err);
1566 }
1567 },
1568 );
1569 }
1570 _ => __A::skip_value(&mut __map)?,
1571 }
1572 }
1573 let m_gravity = match m_gravity {
1574 _serde::__private::Some(__field) => __field,
1575 _serde::__private::None => {
1576 #[cfg(feature = "strict")]
1577 return _serde::__private::Err(
1578 <__A::Error as _serde::de::Error>::missing_field("gravity"),
1579 );
1580 #[cfg(not(feature = "strict"))] Default::default()
1581 }
1582 };
1583 let m_numWheels = match m_numWheels {
1584 _serde::__private::Some(__field) => __field,
1585 _serde::__private::None => {
1586 #[cfg(feature = "strict")]
1587 return _serde::__private::Err(
1588 <__A::Error as _serde::de::Error>::missing_field(
1589 "numWheels",
1590 ),
1591 );
1592 #[cfg(not(feature = "strict"))] Default::default()
1593 }
1594 };
1595 let m_chassisOrientation = match m_chassisOrientation {
1596 _serde::__private::Some(__field) => __field,
1597 _serde::__private::None => {
1598 #[cfg(feature = "strict")]
1599 return _serde::__private::Err(
1600 <__A::Error as _serde::de::Error>::missing_field(
1601 "chassisOrientation",
1602 ),
1603 );
1604 #[cfg(not(feature = "strict"))] Default::default()
1605 }
1606 };
1607 let m_torqueRollFactor = match m_torqueRollFactor {
1608 _serde::__private::Some(__field) => __field,
1609 _serde::__private::None => {
1610 #[cfg(feature = "strict")]
1611 return _serde::__private::Err(
1612 <__A::Error as _serde::de::Error>::missing_field(
1613 "torqueRollFactor",
1614 ),
1615 );
1616 #[cfg(not(feature = "strict"))] Default::default()
1617 }
1618 };
1619 let m_torquePitchFactor = match m_torquePitchFactor {
1620 _serde::__private::Some(__field) => __field,
1621 _serde::__private::None => {
1622 #[cfg(feature = "strict")]
1623 return _serde::__private::Err(
1624 <__A::Error as _serde::de::Error>::missing_field(
1625 "torquePitchFactor",
1626 ),
1627 );
1628 #[cfg(not(feature = "strict"))] Default::default()
1629 }
1630 };
1631 let m_torqueYawFactor = match m_torqueYawFactor {
1632 _serde::__private::Some(__field) => __field,
1633 _serde::__private::None => {
1634 #[cfg(feature = "strict")]
1635 return _serde::__private::Err(
1636 <__A::Error as _serde::de::Error>::missing_field(
1637 "torqueYawFactor",
1638 ),
1639 );
1640 #[cfg(not(feature = "strict"))] Default::default()
1641 }
1642 };
1643 let m_extraTorqueFactor = match m_extraTorqueFactor {
1644 _serde::__private::Some(__field) => __field,
1645 _serde::__private::None => {
1646 #[cfg(feature = "strict")]
1647 return _serde::__private::Err(
1648 <__A::Error as _serde::de::Error>::missing_field(
1649 "extraTorqueFactor",
1650 ),
1651 );
1652 #[cfg(not(feature = "strict"))] Default::default()
1653 }
1654 };
1655 let m_maxVelocityForPositionalFriction = match m_maxVelocityForPositionalFriction {
1656 _serde::__private::Some(__field) => __field,
1657 _serde::__private::None => {
1658 #[cfg(feature = "strict")]
1659 return _serde::__private::Err(
1660 <__A::Error as _serde::de::Error>::missing_field(
1661 "maxVelocityForPositionalFriction",
1662 ),
1663 );
1664 #[cfg(not(feature = "strict"))] Default::default()
1665 }
1666 };
1667 let m_chassisUnitInertiaYaw = match m_chassisUnitInertiaYaw {
1668 _serde::__private::Some(__field) => __field,
1669 _serde::__private::None => {
1670 #[cfg(feature = "strict")]
1671 return _serde::__private::Err(
1672 <__A::Error as _serde::de::Error>::missing_field(
1673 "chassisUnitInertiaYaw",
1674 ),
1675 );
1676 #[cfg(not(feature = "strict"))] Default::default()
1677 }
1678 };
1679 let m_chassisUnitInertiaRoll = match m_chassisUnitInertiaRoll {
1680 _serde::__private::Some(__field) => __field,
1681 _serde::__private::None => {
1682 #[cfg(feature = "strict")]
1683 return _serde::__private::Err(
1684 <__A::Error as _serde::de::Error>::missing_field(
1685 "chassisUnitInertiaRoll",
1686 ),
1687 );
1688 #[cfg(not(feature = "strict"))] Default::default()
1689 }
1690 };
1691 let m_chassisUnitInertiaPitch = match m_chassisUnitInertiaPitch {
1692 _serde::__private::Some(__field) => __field,
1693 _serde::__private::None => {
1694 #[cfg(feature = "strict")]
1695 return _serde::__private::Err(
1696 <__A::Error as _serde::de::Error>::missing_field(
1697 "chassisUnitInertiaPitch",
1698 ),
1699 );
1700 #[cfg(not(feature = "strict"))] Default::default()
1701 }
1702 };
1703 let m_frictionEqualizer = match m_frictionEqualizer {
1704 _serde::__private::Some(__field) => __field,
1705 _serde::__private::None => {
1706 #[cfg(feature = "strict")]
1707 return _serde::__private::Err(
1708 <__A::Error as _serde::de::Error>::missing_field(
1709 "frictionEqualizer",
1710 ),
1711 );
1712 #[cfg(not(feature = "strict"))] Default::default()
1713 }
1714 };
1715 let m_normalClippingAngleCos = match m_normalClippingAngleCos {
1716 _serde::__private::Some(__field) => __field,
1717 _serde::__private::None => {
1718 #[cfg(feature = "strict")]
1719 return _serde::__private::Err(
1720 <__A::Error as _serde::de::Error>::missing_field(
1721 "normalClippingAngleCos",
1722 ),
1723 );
1724 #[cfg(not(feature = "strict"))] Default::default()
1725 }
1726 };
1727 let m_maxFrictionSolverMassRatio = match m_maxFrictionSolverMassRatio {
1728 _serde::__private::Some(__field) => __field,
1729 _serde::__private::None => {
1730 #[cfg(feature = "strict")]
1731 return _serde::__private::Err(
1732 <__A::Error as _serde::de::Error>::missing_field(
1733 "maxFrictionSolverMassRatio",
1734 ),
1735 );
1736 #[cfg(not(feature = "strict"))] Default::default()
1737 }
1738 };
1739 let m_wheelParams = match m_wheelParams {
1740 _serde::__private::Some(__field) => __field,
1741 _serde::__private::None => {
1742 #[cfg(feature = "strict")]
1743 return _serde::__private::Err(
1744 <__A::Error as _serde::de::Error>::missing_field(
1745 "wheelParams",
1746 ),
1747 );
1748 #[cfg(not(feature = "strict"))] Default::default()
1749 }
1750 };
1751 let m_numWheelsPerAxle = match m_numWheelsPerAxle {
1752 _serde::__private::Some(__field) => __field,
1753 _serde::__private::None => {
1754 #[cfg(feature = "strict")]
1755 return _serde::__private::Err(
1756 <__A::Error as _serde::de::Error>::missing_field(
1757 "numWheelsPerAxle",
1758 ),
1759 );
1760 #[cfg(not(feature = "strict"))] Default::default()
1761 }
1762 };
1763 let m_frictionDescription = match m_frictionDescription {
1764 _serde::__private::Some(__field) => __field,
1765 _serde::__private::None => {
1766 #[cfg(feature = "strict")]
1767 return _serde::__private::Err(
1768 <__A::Error as _serde::de::Error>::missing_field(
1769 "frictionDescription",
1770 ),
1771 );
1772 #[cfg(not(feature = "strict"))] Default::default()
1773 }
1774 };
1775 let m_chassisFrictionInertiaInvDiag = match m_chassisFrictionInertiaInvDiag {
1776 _serde::__private::Some(__field) => __field,
1777 _serde::__private::None => {
1778 #[cfg(feature = "strict")]
1779 return _serde::__private::Err(
1780 <__A::Error as _serde::de::Error>::missing_field(
1781 "chassisFrictionInertiaInvDiag",
1782 ),
1783 );
1784 #[cfg(not(feature = "strict"))] Default::default()
1785 }
1786 };
1787 let m_alreadyInitialised = match m_alreadyInitialised {
1788 _serde::__private::Some(__field) => __field,
1789 _serde::__private::None => {
1790 #[cfg(feature = "strict")]
1791 return _serde::__private::Err(
1792 <__A::Error as _serde::de::Error>::missing_field(
1793 "alreadyInitialised",
1794 ),
1795 );
1796 #[cfg(not(feature = "strict"))] Default::default()
1797 }
1798 };
1799 let __ptr = None;
1800 let parent = hkBaseObject { __ptr };
1801 let parent = hkReferencedObject {
1802 __ptr,
1803 parent,
1804 ..Default::default()
1805 };
1806 let __ptr = __A::class_ptr(&mut __map);
1807 _serde::__private::Ok(hkpVehicleData {
1808 __ptr,
1809 parent,
1810 m_gravity,
1811 m_numWheels,
1812 m_chassisOrientation,
1813 m_torqueRollFactor,
1814 m_torquePitchFactor,
1815 m_torqueYawFactor,
1816 m_extraTorqueFactor,
1817 m_maxVelocityForPositionalFriction,
1818 m_chassisUnitInertiaYaw,
1819 m_chassisUnitInertiaRoll,
1820 m_chassisUnitInertiaPitch,
1821 m_frictionEqualizer,
1822 m_normalClippingAngleCos,
1823 m_maxFrictionSolverMassRatio,
1824 m_wheelParams,
1825 m_numWheelsPerAxle,
1826 m_frictionDescription,
1827 m_chassisFrictionInertiaInvDiag,
1828 m_alreadyInitialised,
1829 })
1830 }
1831 }
1832 const FIELDS: &[&str] = &[
1833 "gravity",
1834 "numWheels",
1835 "chassisOrientation",
1836 "torqueRollFactor",
1837 "torquePitchFactor",
1838 "torqueYawFactor",
1839 "extraTorqueFactor",
1840 "maxVelocityForPositionalFriction",
1841 "chassisUnitInertiaYaw",
1842 "chassisUnitInertiaRoll",
1843 "chassisUnitInertiaPitch",
1844 "frictionEqualizer",
1845 "normalClippingAngleCos",
1846 "maxFrictionSolverMassRatio",
1847 "wheelParams",
1848 "numWheelsPerAxle",
1849 "frictionDescription",
1850 "chassisFrictionInertiaInvDiag",
1851 "alreadyInitialised",
1852 ];
1853 _serde::Deserializer::deserialize_struct(
1854 deserializer,
1855 "hkpVehicleData",
1856 FIELDS,
1857 __hkpVehicleDataVisitor {
1858 marker: _serde::__private::PhantomData::<hkpVehicleData>,
1859 lifetime: _serde::__private::PhantomData,
1860 },
1861 )
1862 }
1863 }
1864};