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 hkpVehicleInstanceWheelInfo {
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(rename = "contactPoint"))]
31 #[cfg_attr(feature = "serde", serde(rename = "contactPoint"))]
32 pub m_contactPoint: hkContactPoint,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "contactFriction"))]
38 #[cfg_attr(feature = "serde", serde(rename = "contactFriction"))]
39 pub m_contactFriction: f32,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "contactBody"))]
46 #[cfg_attr(feature = "serde", serde(rename = "contactBody"))]
47 pub m_contactBody: Pointer,
48 #[cfg_attr(feature = "json_schema", schemars(rename = "contactShapeKey"))]
53 #[cfg_attr(feature = "serde", serde(rename = "contactShapeKey"))]
54 pub m_contactShapeKey: [u32; 8usize],
55 #[cfg_attr(feature = "json_schema", schemars(rename = "hardPointWs"))]
60 #[cfg_attr(feature = "serde", serde(rename = "hardPointWs"))]
61 pub m_hardPointWs: Vector4,
62 #[cfg_attr(feature = "json_schema", schemars(rename = "rayEndPointWs"))]
67 #[cfg_attr(feature = "serde", serde(rename = "rayEndPointWs"))]
68 pub m_rayEndPointWs: Vector4,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "currentSuspensionLength"))]
74 #[cfg_attr(feature = "serde", serde(rename = "currentSuspensionLength"))]
75 pub m_currentSuspensionLength: f32,
76 #[cfg_attr(feature = "json_schema", schemars(rename = "suspensionDirectionWs"))]
81 #[cfg_attr(feature = "serde", serde(rename = "suspensionDirectionWs"))]
82 pub m_suspensionDirectionWs: Vector4,
83 #[cfg_attr(feature = "json_schema", schemars(rename = "spinAxisChassisSpace"))]
88 #[cfg_attr(feature = "serde", serde(rename = "spinAxisChassisSpace"))]
89 pub m_spinAxisChassisSpace: Vector4,
90 #[cfg_attr(feature = "json_schema", schemars(rename = "spinAxisWs"))]
95 #[cfg_attr(feature = "serde", serde(rename = "spinAxisWs"))]
96 pub m_spinAxisWs: Vector4,
97 #[cfg_attr(
102 feature = "json_schema",
103 schemars(rename = "steeringOrientationChassisSpace")
104 )]
105 #[cfg_attr(feature = "serde", serde(rename = "steeringOrientationChassisSpace"))]
106 pub m_steeringOrientationChassisSpace: Quaternion,
107 #[cfg_attr(feature = "json_schema", schemars(rename = "spinVelocity"))]
112 #[cfg_attr(feature = "serde", serde(rename = "spinVelocity"))]
113 pub m_spinVelocity: f32,
114 #[cfg_attr(feature = "json_schema", schemars(rename = "spinAngle"))]
119 #[cfg_attr(feature = "serde", serde(rename = "spinAngle"))]
120 pub m_spinAngle: f32,
121 #[cfg_attr(feature = "json_schema", schemars(rename = "skidEnergyDensity"))]
126 #[cfg_attr(feature = "serde", serde(rename = "skidEnergyDensity"))]
127 pub m_skidEnergyDensity: f32,
128 #[cfg_attr(feature = "json_schema", schemars(rename = "sideForce"))]
133 #[cfg_attr(feature = "serde", serde(rename = "sideForce"))]
134 pub m_sideForce: f32,
135 #[cfg_attr(feature = "json_schema", schemars(rename = "forwardSlipVelocity"))]
140 #[cfg_attr(feature = "serde", serde(rename = "forwardSlipVelocity"))]
141 pub m_forwardSlipVelocity: f32,
142 #[cfg_attr(feature = "json_schema", schemars(rename = "sideSlipVelocity"))]
147 #[cfg_attr(feature = "serde", serde(rename = "sideSlipVelocity"))]
148 pub m_sideSlipVelocity: f32,
149}
150const _: () = {
151 use havok_serde as _serde;
152 impl _serde::HavokClass for hkpVehicleInstanceWheelInfo {
153 #[inline]
154 fn name(&self) -> &'static str {
155 "hkpVehicleInstanceWheelInfo"
156 }
157 #[inline]
158 fn signature(&self) -> _serde::__private::Signature {
159 _serde::__private::Signature::new(0x99f693f0)
160 }
161 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
162 fn deps_indexes(&self) -> Vec<usize> {
163 let mut v = Vec::new();
164 v.extend(self.m_contactPoint.deps_indexes());
165 v.push(self.m_contactBody.get());
166 v
167 }
168 }
169 impl _serde::Serialize for hkpVehicleInstanceWheelInfo {
170 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
171 where
172 S: _serde::ser::Serializer,
173 {
174 let class_meta = self
175 .__ptr
176 .map(|name| (name, _serde::__private::Signature::new(0x99f693f0)));
177 let mut serializer = __serializer
178 .serialize_struct(
179 "hkpVehicleInstanceWheelInfo",
180 class_meta,
181 (224u64, 224u64),
182 )?;
183 serializer.serialize_field("contactPoint", &self.m_contactPoint)?;
184 serializer.serialize_field("contactFriction", &self.m_contactFriction)?;
185 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
186 serializer.skip_field("contactBody", &self.m_contactBody)?;
187 serializer
188 .serialize_fixed_array_field(
189 "contactShapeKey",
190 self.m_contactShapeKey.as_slice(),
191 TypeSize::NonPtr,
192 )?;
193 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
194 serializer.serialize_field("hardPointWs", &self.m_hardPointWs)?;
195 serializer.serialize_field("rayEndPointWs", &self.m_rayEndPointWs)?;
196 serializer
197 .serialize_field(
198 "currentSuspensionLength",
199 &self.m_currentSuspensionLength,
200 )?;
201 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 12usize].as_slice())?;
202 serializer
203 .serialize_field(
204 "suspensionDirectionWs",
205 &self.m_suspensionDirectionWs,
206 )?;
207 serializer
208 .serialize_field("spinAxisChassisSpace", &self.m_spinAxisChassisSpace)?;
209 serializer.serialize_field("spinAxisWs", &self.m_spinAxisWs)?;
210 serializer
211 .serialize_field(
212 "steeringOrientationChassisSpace",
213 &self.m_steeringOrientationChassisSpace,
214 )?;
215 serializer.serialize_field("spinVelocity", &self.m_spinVelocity)?;
216 serializer.serialize_field("spinAngle", &self.m_spinAngle)?;
217 serializer.serialize_field("skidEnergyDensity", &self.m_skidEnergyDensity)?;
218 serializer.serialize_field("sideForce", &self.m_sideForce)?;
219 serializer
220 .serialize_field("forwardSlipVelocity", &self.m_forwardSlipVelocity)?;
221 serializer.serialize_field("sideSlipVelocity", &self.m_sideSlipVelocity)?;
222 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
223 serializer.end()
224 }
225 }
226};
227#[doc(hidden)]
228#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
229const _: () = {
230 use havok_serde as _serde;
231 #[automatically_derived]
232 impl<'de> _serde::Deserialize<'de> for hkpVehicleInstanceWheelInfo {
233 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
234 where
235 __D: _serde::Deserializer<'de>,
236 {
237 #[allow(non_camel_case_types)]
238 enum __Field {
239 m_contactPoint,
240 m_contactFriction,
241 m_contactShapeKey,
242 m_hardPointWs,
243 m_rayEndPointWs,
244 m_currentSuspensionLength,
245 m_suspensionDirectionWs,
246 m_spinAxisChassisSpace,
247 m_spinAxisWs,
248 m_steeringOrientationChassisSpace,
249 m_spinVelocity,
250 m_spinAngle,
251 m_skidEnergyDensity,
252 m_sideForce,
253 m_forwardSlipVelocity,
254 m_sideSlipVelocity,
255 __ignore,
256 }
257 struct __FieldVisitor;
258 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
259 type Value = __Field;
260 fn expecting(
261 &self,
262 __formatter: &mut core::fmt::Formatter,
263 ) -> core::fmt::Result {
264 core::fmt::Formatter::write_str(__formatter, "field identifier")
265 }
266 #[allow(clippy::match_single_binding)]
268 #[allow(clippy::reversed_empty_ranges)]
269 #[allow(clippy::single_match)]
270 fn visit_key<__E>(
271 self,
272 __value: &str,
273 ) -> core::result::Result<Self::Value, __E>
274 where
275 __E: _serde::de::Error,
276 {
277 match __value {
278 "contactPoint" => Ok(__Field::m_contactPoint),
279 "contactFriction" => Ok(__Field::m_contactFriction),
280 "contactShapeKey" => Ok(__Field::m_contactShapeKey),
281 "hardPointWs" => Ok(__Field::m_hardPointWs),
282 "rayEndPointWs" => Ok(__Field::m_rayEndPointWs),
283 "currentSuspensionLength" => {
284 Ok(__Field::m_currentSuspensionLength)
285 }
286 "suspensionDirectionWs" => Ok(__Field::m_suspensionDirectionWs),
287 "spinAxisChassisSpace" => Ok(__Field::m_spinAxisChassisSpace),
288 "spinAxisWs" => Ok(__Field::m_spinAxisWs),
289 "steeringOrientationChassisSpace" => {
290 Ok(__Field::m_steeringOrientationChassisSpace)
291 }
292 "spinVelocity" => Ok(__Field::m_spinVelocity),
293 "spinAngle" => Ok(__Field::m_spinAngle),
294 "skidEnergyDensity" => Ok(__Field::m_skidEnergyDensity),
295 "sideForce" => Ok(__Field::m_sideForce),
296 "forwardSlipVelocity" => Ok(__Field::m_forwardSlipVelocity),
297 "sideSlipVelocity" => Ok(__Field::m_sideSlipVelocity),
298 _ => Ok(__Field::__ignore),
299 }
300 }
301 }
302 impl<'de> _serde::Deserialize<'de> for __Field {
303 #[inline]
304 fn deserialize<__D>(
305 __deserializer: __D,
306 ) -> core::result::Result<Self, __D::Error>
307 where
308 __D: _serde::Deserializer<'de>,
309 {
310 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
311 }
312 }
313 struct __hkpVehicleInstanceWheelInfoVisitor<'de> {
314 marker: _serde::__private::PhantomData<hkpVehicleInstanceWheelInfo>,
315 lifetime: _serde::__private::PhantomData<&'de ()>,
316 }
317 #[allow(clippy::match_single_binding)]
318 #[allow(clippy::reversed_empty_ranges)]
319 #[allow(clippy::single_match)]
320 impl<'de> _serde::de::Visitor<'de>
321 for __hkpVehicleInstanceWheelInfoVisitor<'de> {
322 type Value = hkpVehicleInstanceWheelInfo;
323 fn expecting(
324 &self,
325 __formatter: &mut core::fmt::Formatter,
326 ) -> core::fmt::Result {
327 core::fmt::Formatter::write_str(
328 __formatter,
329 "struct hkpVehicleInstanceWheelInfo",
330 )
331 }
332 fn visit_struct_for_bytes<__A>(
333 self,
334 mut __map: __A,
335 ) -> _serde::__private::Result<Self::Value, __A::Error>
336 where
337 __A: _serde::de::MapAccess<'de>,
338 {
339 let __ptr = __A::class_ptr(&mut __map);
340 let mut m_contactPoint: _serde::__private::Option<hkContactPoint> = _serde::__private::None;
341 let mut m_contactFriction: _serde::__private::Option<f32> = _serde::__private::None;
342 let mut m_contactBody: _serde::__private::Option<Pointer> = _serde::__private::None;
343 let mut m_contactShapeKey: _serde::__private::Option<
344 [u32; 8usize],
345 > = _serde::__private::None;
346 let mut m_hardPointWs: _serde::__private::Option<Vector4> = _serde::__private::None;
347 let mut m_rayEndPointWs: _serde::__private::Option<Vector4> = _serde::__private::None;
348 let mut m_currentSuspensionLength: _serde::__private::Option<f32> = _serde::__private::None;
349 let mut m_suspensionDirectionWs: _serde::__private::Option<
350 Vector4,
351 > = _serde::__private::None;
352 let mut m_spinAxisChassisSpace: _serde::__private::Option<Vector4> = _serde::__private::None;
353 let mut m_spinAxisWs: _serde::__private::Option<Vector4> = _serde::__private::None;
354 let mut m_steeringOrientationChassisSpace: _serde::__private::Option<
355 Quaternion,
356 > = _serde::__private::None;
357 let mut m_spinVelocity: _serde::__private::Option<f32> = _serde::__private::None;
358 let mut m_spinAngle: _serde::__private::Option<f32> = _serde::__private::None;
359 let mut m_skidEnergyDensity: _serde::__private::Option<f32> = _serde::__private::None;
360 let mut m_sideForce: _serde::__private::Option<f32> = _serde::__private::None;
361 let mut m_forwardSlipVelocity: _serde::__private::Option<f32> = _serde::__private::None;
362 let mut m_sideSlipVelocity: _serde::__private::Option<f32> = _serde::__private::None;
363 for i in 0..17usize {
364 match i {
365 0usize => {
366 if _serde::__private::Option::is_some(&m_contactPoint) {
367 return _serde::__private::Err(
368 <__A::Error as _serde::de::Error>::duplicate_field(
369 "contactPoint",
370 ),
371 );
372 }
373 m_contactPoint = _serde::__private::Some(
374 match __A::next_value::<hkContactPoint>(&mut __map) {
375 _serde::__private::Ok(__val) => __val,
376 _serde::__private::Err(__err) => {
377 return _serde::__private::Err(__err);
378 }
379 },
380 );
381 }
382 1usize => {
383 if _serde::__private::Option::is_some(&m_contactFriction) {
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::duplicate_field(
386 "contactFriction",
387 ),
388 );
389 }
390 m_contactFriction = _serde::__private::Some(
391 match __A::next_value::<f32>(&mut __map) {
392 _serde::__private::Ok(__val) => __val,
393 _serde::__private::Err(__err) => {
394 return _serde::__private::Err(__err);
395 }
396 },
397 );
398 }
399 2usize => {
400 if _serde::__private::Option::is_some(&m_contactBody) {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "contactBody",
404 ),
405 );
406 }
407 __A::pad(&mut __map, 0usize, 4usize)?;
408 m_contactBody = _serde::__private::Some(
409 match __A::next_value::<Pointer>(&mut __map) {
410 _serde::__private::Ok(__val) => __val,
411 _serde::__private::Err(__err) => {
412 return _serde::__private::Err(__err);
413 }
414 },
415 );
416 }
417 3usize => {
418 if _serde::__private::Option::is_some(&m_contactShapeKey) {
419 return _serde::__private::Err(
420 <__A::Error as _serde::de::Error>::duplicate_field(
421 "contactShapeKey",
422 ),
423 );
424 }
425 m_contactShapeKey = _serde::__private::Some(
426 match __A::next_value::<[u32; 8usize]>(&mut __map) {
427 _serde::__private::Ok(__val) => __val,
428 _serde::__private::Err(__err) => {
429 return _serde::__private::Err(__err);
430 }
431 },
432 );
433 }
434 4usize => {
435 if _serde::__private::Option::is_some(&m_hardPointWs) {
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::duplicate_field(
438 "hardPointWs",
439 ),
440 );
441 }
442 __A::pad(&mut __map, 8usize, 0usize)?;
443 m_hardPointWs = _serde::__private::Some(
444 match __A::next_value::<Vector4>(&mut __map) {
445 _serde::__private::Ok(__val) => __val,
446 _serde::__private::Err(__err) => {
447 return _serde::__private::Err(__err);
448 }
449 },
450 );
451 }
452 5usize => {
453 if _serde::__private::Option::is_some(&m_rayEndPointWs) {
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::duplicate_field(
456 "rayEndPointWs",
457 ),
458 );
459 }
460 m_rayEndPointWs = _serde::__private::Some(
461 match __A::next_value::<Vector4>(&mut __map) {
462 _serde::__private::Ok(__val) => __val,
463 _serde::__private::Err(__err) => {
464 return _serde::__private::Err(__err);
465 }
466 },
467 );
468 }
469 6usize => {
470 if _serde::__private::Option::is_some(
471 &m_currentSuspensionLength,
472 ) {
473 return _serde::__private::Err(
474 <__A::Error as _serde::de::Error>::duplicate_field(
475 "currentSuspensionLength",
476 ),
477 );
478 }
479 m_currentSuspensionLength = _serde::__private::Some(
480 match __A::next_value::<f32>(&mut __map) {
481 _serde::__private::Ok(__val) => __val,
482 _serde::__private::Err(__err) => {
483 return _serde::__private::Err(__err);
484 }
485 },
486 );
487 }
488 7usize => {
489 if _serde::__private::Option::is_some(
490 &m_suspensionDirectionWs,
491 ) {
492 return _serde::__private::Err(
493 <__A::Error as _serde::de::Error>::duplicate_field(
494 "suspensionDirectionWs",
495 ),
496 );
497 }
498 __A::pad(&mut __map, 12usize, 12usize)?;
499 m_suspensionDirectionWs = _serde::__private::Some(
500 match __A::next_value::<Vector4>(&mut __map) {
501 _serde::__private::Ok(__val) => __val,
502 _serde::__private::Err(__err) => {
503 return _serde::__private::Err(__err);
504 }
505 },
506 );
507 }
508 8usize => {
509 if _serde::__private::Option::is_some(
510 &m_spinAxisChassisSpace,
511 ) {
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::duplicate_field(
514 "spinAxisChassisSpace",
515 ),
516 );
517 }
518 m_spinAxisChassisSpace = _serde::__private::Some(
519 match __A::next_value::<Vector4>(&mut __map) {
520 _serde::__private::Ok(__val) => __val,
521 _serde::__private::Err(__err) => {
522 return _serde::__private::Err(__err);
523 }
524 },
525 );
526 }
527 9usize => {
528 if _serde::__private::Option::is_some(&m_spinAxisWs) {
529 return _serde::__private::Err(
530 <__A::Error as _serde::de::Error>::duplicate_field(
531 "spinAxisWs",
532 ),
533 );
534 }
535 m_spinAxisWs = _serde::__private::Some(
536 match __A::next_value::<Vector4>(&mut __map) {
537 _serde::__private::Ok(__val) => __val,
538 _serde::__private::Err(__err) => {
539 return _serde::__private::Err(__err);
540 }
541 },
542 );
543 }
544 10usize => {
545 if _serde::__private::Option::is_some(
546 &m_steeringOrientationChassisSpace,
547 ) {
548 return _serde::__private::Err(
549 <__A::Error as _serde::de::Error>::duplicate_field(
550 "steeringOrientationChassisSpace",
551 ),
552 );
553 }
554 m_steeringOrientationChassisSpace = _serde::__private::Some(
555 match __A::next_value::<Quaternion>(&mut __map) {
556 _serde::__private::Ok(__val) => __val,
557 _serde::__private::Err(__err) => {
558 return _serde::__private::Err(__err);
559 }
560 },
561 );
562 }
563 11usize => {
564 if _serde::__private::Option::is_some(&m_spinVelocity) {
565 return _serde::__private::Err(
566 <__A::Error as _serde::de::Error>::duplicate_field(
567 "spinVelocity",
568 ),
569 );
570 }
571 m_spinVelocity = _serde::__private::Some(
572 match __A::next_value::<f32>(&mut __map) {
573 _serde::__private::Ok(__val) => __val,
574 _serde::__private::Err(__err) => {
575 return _serde::__private::Err(__err);
576 }
577 },
578 );
579 }
580 12usize => {
581 if _serde::__private::Option::is_some(&m_spinAngle) {
582 return _serde::__private::Err(
583 <__A::Error as _serde::de::Error>::duplicate_field(
584 "spinAngle",
585 ),
586 );
587 }
588 m_spinAngle = _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 13usize => {
598 if _serde::__private::Option::is_some(
599 &m_skidEnergyDensity,
600 ) {
601 return _serde::__private::Err(
602 <__A::Error as _serde::de::Error>::duplicate_field(
603 "skidEnergyDensity",
604 ),
605 );
606 }
607 m_skidEnergyDensity = _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 14usize => {
617 if _serde::__private::Option::is_some(&m_sideForce) {
618 return _serde::__private::Err(
619 <__A::Error as _serde::de::Error>::duplicate_field(
620 "sideForce",
621 ),
622 );
623 }
624 m_sideForce = _serde::__private::Some(
625 match __A::next_value::<f32>(&mut __map) {
626 _serde::__private::Ok(__val) => __val,
627 _serde::__private::Err(__err) => {
628 return _serde::__private::Err(__err);
629 }
630 },
631 );
632 }
633 15usize => {
634 if _serde::__private::Option::is_some(
635 &m_forwardSlipVelocity,
636 ) {
637 return _serde::__private::Err(
638 <__A::Error as _serde::de::Error>::duplicate_field(
639 "forwardSlipVelocity",
640 ),
641 );
642 }
643 m_forwardSlipVelocity = _serde::__private::Some(
644 match __A::next_value::<f32>(&mut __map) {
645 _serde::__private::Ok(__val) => __val,
646 _serde::__private::Err(__err) => {
647 return _serde::__private::Err(__err);
648 }
649 },
650 );
651 }
652 16usize => {
653 if _serde::__private::Option::is_some(&m_sideSlipVelocity) {
654 return _serde::__private::Err(
655 <__A::Error as _serde::de::Error>::duplicate_field(
656 "sideSlipVelocity",
657 ),
658 );
659 }
660 m_sideSlipVelocity = _serde::__private::Some(
661 match __A::next_value::<f32>(&mut __map) {
662 _serde::__private::Ok(__val) => __val,
663 _serde::__private::Err(__err) => {
664 return _serde::__private::Err(__err);
665 }
666 },
667 );
668 }
669 _ => {}
670 }
671 }
672 __A::pad(&mut __map, 8usize, 8usize)?;
673 let m_contactPoint = match m_contactPoint {
674 _serde::__private::Some(__field) => __field,
675 _serde::__private::None => {
676 return _serde::__private::Err(
677 <__A::Error as _serde::de::Error>::missing_field(
678 "contactPoint",
679 ),
680 );
681 }
682 };
683 let m_contactFriction = match m_contactFriction {
684 _serde::__private::Some(__field) => __field,
685 _serde::__private::None => {
686 return _serde::__private::Err(
687 <__A::Error as _serde::de::Error>::missing_field(
688 "contactFriction",
689 ),
690 );
691 }
692 };
693 let m_contactBody = match m_contactBody {
694 _serde::__private::Some(__field) => __field,
695 _serde::__private::None => {
696 return _serde::__private::Err(
697 <__A::Error as _serde::de::Error>::missing_field(
698 "contactBody",
699 ),
700 );
701 }
702 };
703 let m_contactShapeKey = match m_contactShapeKey {
704 _serde::__private::Some(__field) => __field,
705 _serde::__private::None => {
706 return _serde::__private::Err(
707 <__A::Error as _serde::de::Error>::missing_field(
708 "contactShapeKey",
709 ),
710 );
711 }
712 };
713 let m_hardPointWs = match m_hardPointWs {
714 _serde::__private::Some(__field) => __field,
715 _serde::__private::None => {
716 return _serde::__private::Err(
717 <__A::Error as _serde::de::Error>::missing_field(
718 "hardPointWs",
719 ),
720 );
721 }
722 };
723 let m_rayEndPointWs = match m_rayEndPointWs {
724 _serde::__private::Some(__field) => __field,
725 _serde::__private::None => {
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::missing_field(
728 "rayEndPointWs",
729 ),
730 );
731 }
732 };
733 let m_currentSuspensionLength = match m_currentSuspensionLength {
734 _serde::__private::Some(__field) => __field,
735 _serde::__private::None => {
736 return _serde::__private::Err(
737 <__A::Error as _serde::de::Error>::missing_field(
738 "currentSuspensionLength",
739 ),
740 );
741 }
742 };
743 let m_suspensionDirectionWs = match m_suspensionDirectionWs {
744 _serde::__private::Some(__field) => __field,
745 _serde::__private::None => {
746 return _serde::__private::Err(
747 <__A::Error as _serde::de::Error>::missing_field(
748 "suspensionDirectionWs",
749 ),
750 );
751 }
752 };
753 let m_spinAxisChassisSpace = match m_spinAxisChassisSpace {
754 _serde::__private::Some(__field) => __field,
755 _serde::__private::None => {
756 return _serde::__private::Err(
757 <__A::Error as _serde::de::Error>::missing_field(
758 "spinAxisChassisSpace",
759 ),
760 );
761 }
762 };
763 let m_spinAxisWs = match m_spinAxisWs {
764 _serde::__private::Some(__field) => __field,
765 _serde::__private::None => {
766 return _serde::__private::Err(
767 <__A::Error as _serde::de::Error>::missing_field(
768 "spinAxisWs",
769 ),
770 );
771 }
772 };
773 let m_steeringOrientationChassisSpace = match m_steeringOrientationChassisSpace {
774 _serde::__private::Some(__field) => __field,
775 _serde::__private::None => {
776 return _serde::__private::Err(
777 <__A::Error as _serde::de::Error>::missing_field(
778 "steeringOrientationChassisSpace",
779 ),
780 );
781 }
782 };
783 let m_spinVelocity = match m_spinVelocity {
784 _serde::__private::Some(__field) => __field,
785 _serde::__private::None => {
786 return _serde::__private::Err(
787 <__A::Error as _serde::de::Error>::missing_field(
788 "spinVelocity",
789 ),
790 );
791 }
792 };
793 let m_spinAngle = match m_spinAngle {
794 _serde::__private::Some(__field) => __field,
795 _serde::__private::None => {
796 return _serde::__private::Err(
797 <__A::Error as _serde::de::Error>::missing_field(
798 "spinAngle",
799 ),
800 );
801 }
802 };
803 let m_skidEnergyDensity = match m_skidEnergyDensity {
804 _serde::__private::Some(__field) => __field,
805 _serde::__private::None => {
806 return _serde::__private::Err(
807 <__A::Error as _serde::de::Error>::missing_field(
808 "skidEnergyDensity",
809 ),
810 );
811 }
812 };
813 let m_sideForce = match m_sideForce {
814 _serde::__private::Some(__field) => __field,
815 _serde::__private::None => {
816 return _serde::__private::Err(
817 <__A::Error as _serde::de::Error>::missing_field(
818 "sideForce",
819 ),
820 );
821 }
822 };
823 let m_forwardSlipVelocity = match m_forwardSlipVelocity {
824 _serde::__private::Some(__field) => __field,
825 _serde::__private::None => {
826 return _serde::__private::Err(
827 <__A::Error as _serde::de::Error>::missing_field(
828 "forwardSlipVelocity",
829 ),
830 );
831 }
832 };
833 let m_sideSlipVelocity = match m_sideSlipVelocity {
834 _serde::__private::Some(__field) => __field,
835 _serde::__private::None => {
836 return _serde::__private::Err(
837 <__A::Error as _serde::de::Error>::missing_field(
838 "sideSlipVelocity",
839 ),
840 );
841 }
842 };
843 _serde::__private::Ok(hkpVehicleInstanceWheelInfo {
844 __ptr,
845 m_contactPoint,
846 m_contactFriction,
847 m_contactBody,
848 m_contactShapeKey,
849 m_hardPointWs,
850 m_rayEndPointWs,
851 m_currentSuspensionLength,
852 m_suspensionDirectionWs,
853 m_spinAxisChassisSpace,
854 m_spinAxisWs,
855 m_steeringOrientationChassisSpace,
856 m_spinVelocity,
857 m_spinAngle,
858 m_skidEnergyDensity,
859 m_sideForce,
860 m_forwardSlipVelocity,
861 m_sideSlipVelocity,
862 })
863 }
864 #[allow(clippy::manual_unwrap_or_default)]
865 fn visit_struct<__A>(
866 self,
867 mut __map: __A,
868 ) -> _serde::__private::Result<Self::Value, __A::Error>
869 where
870 __A: _serde::de::MapAccess<'de>,
871 {
872 let mut m_contactPoint: _serde::__private::Option<hkContactPoint> = _serde::__private::None;
873 let mut m_contactFriction: _serde::__private::Option<f32> = _serde::__private::None;
874 let mut m_contactShapeKey: _serde::__private::Option<
875 [u32; 8usize],
876 > = _serde::__private::None;
877 let mut m_hardPointWs: _serde::__private::Option<Vector4> = _serde::__private::None;
878 let mut m_rayEndPointWs: _serde::__private::Option<Vector4> = _serde::__private::None;
879 let mut m_currentSuspensionLength: _serde::__private::Option<f32> = _serde::__private::None;
880 let mut m_suspensionDirectionWs: _serde::__private::Option<
881 Vector4,
882 > = _serde::__private::None;
883 let mut m_spinAxisChassisSpace: _serde::__private::Option<Vector4> = _serde::__private::None;
884 let mut m_spinAxisWs: _serde::__private::Option<Vector4> = _serde::__private::None;
885 let mut m_steeringOrientationChassisSpace: _serde::__private::Option<
886 Quaternion,
887 > = _serde::__private::None;
888 let mut m_spinVelocity: _serde::__private::Option<f32> = _serde::__private::None;
889 let mut m_spinAngle: _serde::__private::Option<f32> = _serde::__private::None;
890 let mut m_skidEnergyDensity: _serde::__private::Option<f32> = _serde::__private::None;
891 let mut m_sideForce: _serde::__private::Option<f32> = _serde::__private::None;
892 let mut m_forwardSlipVelocity: _serde::__private::Option<f32> = _serde::__private::None;
893 let mut m_sideSlipVelocity: _serde::__private::Option<f32> = _serde::__private::None;
894 while let _serde::__private::Some(__key) = {
895 __A::next_key::<__Field>(&mut __map)?
896 } {
897 match __key {
898 __Field::m_contactPoint => {
899 #[cfg(
900 any(feature = "strict", feature = "ignore_duplicates")
901 )]
902 if _serde::__private::Option::is_some(&m_contactPoint) {
903 #[cfg(feature = "ignore_duplicates")]
904 {
905 __A::skip_value(&mut __map)?;
906 continue;
907 }
908 #[cfg(feature = "strict")]
909 return _serde::__private::Err(
910 <__A::Error as _serde::de::Error>::duplicate_field(
911 "contactPoint",
912 ),
913 );
914 }
915 m_contactPoint = _serde::__private::Some(
916 match __A::next_value::<hkContactPoint>(&mut __map) {
917 _serde::__private::Ok(__val) => __val,
918 _serde::__private::Err(__err) => {
919 return _serde::__private::Err(__err);
920 }
921 },
922 );
923 }
924 __Field::m_contactFriction => {
925 #[cfg(
926 any(feature = "strict", feature = "ignore_duplicates")
927 )]
928 if _serde::__private::Option::is_some(&m_contactFriction) {
929 #[cfg(feature = "ignore_duplicates")]
930 {
931 __A::skip_value(&mut __map)?;
932 continue;
933 }
934 #[cfg(feature = "strict")]
935 return _serde::__private::Err(
936 <__A::Error as _serde::de::Error>::duplicate_field(
937 "contactFriction",
938 ),
939 );
940 }
941 m_contactFriction = _serde::__private::Some(
942 match __A::next_value::<f32>(&mut __map) {
943 _serde::__private::Ok(__val) => __val,
944 _serde::__private::Err(__err) => {
945 return _serde::__private::Err(__err);
946 }
947 },
948 );
949 }
950 __Field::m_contactShapeKey => {
951 #[cfg(
952 any(feature = "strict", feature = "ignore_duplicates")
953 )]
954 if _serde::__private::Option::is_some(&m_contactShapeKey) {
955 #[cfg(feature = "ignore_duplicates")]
956 {
957 __A::skip_value(&mut __map)?;
958 continue;
959 }
960 #[cfg(feature = "strict")]
961 return _serde::__private::Err(
962 <__A::Error as _serde::de::Error>::duplicate_field(
963 "contactShapeKey",
964 ),
965 );
966 }
967 m_contactShapeKey = _serde::__private::Some(
968 match __A::next_value::<[u32; 8usize]>(&mut __map) {
969 _serde::__private::Ok(__val) => __val,
970 _serde::__private::Err(__err) => {
971 return _serde::__private::Err(__err);
972 }
973 },
974 );
975 }
976 __Field::m_hardPointWs => {
977 #[cfg(
978 any(feature = "strict", feature = "ignore_duplicates")
979 )]
980 if _serde::__private::Option::is_some(&m_hardPointWs) {
981 #[cfg(feature = "ignore_duplicates")]
982 {
983 __A::skip_value(&mut __map)?;
984 continue;
985 }
986 #[cfg(feature = "strict")]
987 return _serde::__private::Err(
988 <__A::Error as _serde::de::Error>::duplicate_field(
989 "hardPointWs",
990 ),
991 );
992 }
993 m_hardPointWs = _serde::__private::Some(
994 match __A::next_value::<Vector4>(&mut __map) {
995 _serde::__private::Ok(__val) => __val,
996 _serde::__private::Err(__err) => {
997 return _serde::__private::Err(__err);
998 }
999 },
1000 );
1001 }
1002 __Field::m_rayEndPointWs => {
1003 #[cfg(
1004 any(feature = "strict", feature = "ignore_duplicates")
1005 )]
1006 if _serde::__private::Option::is_some(&m_rayEndPointWs) {
1007 #[cfg(feature = "ignore_duplicates")]
1008 {
1009 __A::skip_value(&mut __map)?;
1010 continue;
1011 }
1012 #[cfg(feature = "strict")]
1013 return _serde::__private::Err(
1014 <__A::Error as _serde::de::Error>::duplicate_field(
1015 "rayEndPointWs",
1016 ),
1017 );
1018 }
1019 m_rayEndPointWs = _serde::__private::Some(
1020 match __A::next_value::<Vector4>(&mut __map) {
1021 _serde::__private::Ok(__val) => __val,
1022 _serde::__private::Err(__err) => {
1023 return _serde::__private::Err(__err);
1024 }
1025 },
1026 );
1027 }
1028 __Field::m_currentSuspensionLength => {
1029 #[cfg(
1030 any(feature = "strict", feature = "ignore_duplicates")
1031 )]
1032 if _serde::__private::Option::is_some(
1033 &m_currentSuspensionLength,
1034 ) {
1035 #[cfg(feature = "ignore_duplicates")]
1036 {
1037 __A::skip_value(&mut __map)?;
1038 continue;
1039 }
1040 #[cfg(feature = "strict")]
1041 return _serde::__private::Err(
1042 <__A::Error as _serde::de::Error>::duplicate_field(
1043 "currentSuspensionLength",
1044 ),
1045 );
1046 }
1047 m_currentSuspensionLength = _serde::__private::Some(
1048 match __A::next_value::<f32>(&mut __map) {
1049 _serde::__private::Ok(__val) => __val,
1050 _serde::__private::Err(__err) => {
1051 return _serde::__private::Err(__err);
1052 }
1053 },
1054 );
1055 }
1056 __Field::m_suspensionDirectionWs => {
1057 #[cfg(
1058 any(feature = "strict", feature = "ignore_duplicates")
1059 )]
1060 if _serde::__private::Option::is_some(
1061 &m_suspensionDirectionWs,
1062 ) {
1063 #[cfg(feature = "ignore_duplicates")]
1064 {
1065 __A::skip_value(&mut __map)?;
1066 continue;
1067 }
1068 #[cfg(feature = "strict")]
1069 return _serde::__private::Err(
1070 <__A::Error as _serde::de::Error>::duplicate_field(
1071 "suspensionDirectionWs",
1072 ),
1073 );
1074 }
1075 m_suspensionDirectionWs = _serde::__private::Some(
1076 match __A::next_value::<Vector4>(&mut __map) {
1077 _serde::__private::Ok(__val) => __val,
1078 _serde::__private::Err(__err) => {
1079 return _serde::__private::Err(__err);
1080 }
1081 },
1082 );
1083 }
1084 __Field::m_spinAxisChassisSpace => {
1085 #[cfg(
1086 any(feature = "strict", feature = "ignore_duplicates")
1087 )]
1088 if _serde::__private::Option::is_some(
1089 &m_spinAxisChassisSpace,
1090 ) {
1091 #[cfg(feature = "ignore_duplicates")]
1092 {
1093 __A::skip_value(&mut __map)?;
1094 continue;
1095 }
1096 #[cfg(feature = "strict")]
1097 return _serde::__private::Err(
1098 <__A::Error as _serde::de::Error>::duplicate_field(
1099 "spinAxisChassisSpace",
1100 ),
1101 );
1102 }
1103 m_spinAxisChassisSpace = _serde::__private::Some(
1104 match __A::next_value::<Vector4>(&mut __map) {
1105 _serde::__private::Ok(__val) => __val,
1106 _serde::__private::Err(__err) => {
1107 return _serde::__private::Err(__err);
1108 }
1109 },
1110 );
1111 }
1112 __Field::m_spinAxisWs => {
1113 #[cfg(
1114 any(feature = "strict", feature = "ignore_duplicates")
1115 )]
1116 if _serde::__private::Option::is_some(&m_spinAxisWs) {
1117 #[cfg(feature = "ignore_duplicates")]
1118 {
1119 __A::skip_value(&mut __map)?;
1120 continue;
1121 }
1122 #[cfg(feature = "strict")]
1123 return _serde::__private::Err(
1124 <__A::Error as _serde::de::Error>::duplicate_field(
1125 "spinAxisWs",
1126 ),
1127 );
1128 }
1129 m_spinAxisWs = _serde::__private::Some(
1130 match __A::next_value::<Vector4>(&mut __map) {
1131 _serde::__private::Ok(__val) => __val,
1132 _serde::__private::Err(__err) => {
1133 return _serde::__private::Err(__err);
1134 }
1135 },
1136 );
1137 }
1138 __Field::m_steeringOrientationChassisSpace => {
1139 #[cfg(
1140 any(feature = "strict", feature = "ignore_duplicates")
1141 )]
1142 if _serde::__private::Option::is_some(
1143 &m_steeringOrientationChassisSpace,
1144 ) {
1145 #[cfg(feature = "ignore_duplicates")]
1146 {
1147 __A::skip_value(&mut __map)?;
1148 continue;
1149 }
1150 #[cfg(feature = "strict")]
1151 return _serde::__private::Err(
1152 <__A::Error as _serde::de::Error>::duplicate_field(
1153 "steeringOrientationChassisSpace",
1154 ),
1155 );
1156 }
1157 m_steeringOrientationChassisSpace = _serde::__private::Some(
1158 match __A::next_value::<Quaternion>(&mut __map) {
1159 _serde::__private::Ok(__val) => __val,
1160 _serde::__private::Err(__err) => {
1161 return _serde::__private::Err(__err);
1162 }
1163 },
1164 );
1165 }
1166 __Field::m_spinVelocity => {
1167 #[cfg(
1168 any(feature = "strict", feature = "ignore_duplicates")
1169 )]
1170 if _serde::__private::Option::is_some(&m_spinVelocity) {
1171 #[cfg(feature = "ignore_duplicates")]
1172 {
1173 __A::skip_value(&mut __map)?;
1174 continue;
1175 }
1176 #[cfg(feature = "strict")]
1177 return _serde::__private::Err(
1178 <__A::Error as _serde::de::Error>::duplicate_field(
1179 "spinVelocity",
1180 ),
1181 );
1182 }
1183 m_spinVelocity = _serde::__private::Some(
1184 match __A::next_value::<f32>(&mut __map) {
1185 _serde::__private::Ok(__val) => __val,
1186 _serde::__private::Err(__err) => {
1187 return _serde::__private::Err(__err);
1188 }
1189 },
1190 );
1191 }
1192 __Field::m_spinAngle => {
1193 #[cfg(
1194 any(feature = "strict", feature = "ignore_duplicates")
1195 )]
1196 if _serde::__private::Option::is_some(&m_spinAngle) {
1197 #[cfg(feature = "ignore_duplicates")]
1198 {
1199 __A::skip_value(&mut __map)?;
1200 continue;
1201 }
1202 #[cfg(feature = "strict")]
1203 return _serde::__private::Err(
1204 <__A::Error as _serde::de::Error>::duplicate_field(
1205 "spinAngle",
1206 ),
1207 );
1208 }
1209 m_spinAngle = _serde::__private::Some(
1210 match __A::next_value::<f32>(&mut __map) {
1211 _serde::__private::Ok(__val) => __val,
1212 _serde::__private::Err(__err) => {
1213 return _serde::__private::Err(__err);
1214 }
1215 },
1216 );
1217 }
1218 __Field::m_skidEnergyDensity => {
1219 #[cfg(
1220 any(feature = "strict", feature = "ignore_duplicates")
1221 )]
1222 if _serde::__private::Option::is_some(
1223 &m_skidEnergyDensity,
1224 ) {
1225 #[cfg(feature = "ignore_duplicates")]
1226 {
1227 __A::skip_value(&mut __map)?;
1228 continue;
1229 }
1230 #[cfg(feature = "strict")]
1231 return _serde::__private::Err(
1232 <__A::Error as _serde::de::Error>::duplicate_field(
1233 "skidEnergyDensity",
1234 ),
1235 );
1236 }
1237 m_skidEnergyDensity = _serde::__private::Some(
1238 match __A::next_value::<f32>(&mut __map) {
1239 _serde::__private::Ok(__val) => __val,
1240 _serde::__private::Err(__err) => {
1241 return _serde::__private::Err(__err);
1242 }
1243 },
1244 );
1245 }
1246 __Field::m_sideForce => {
1247 #[cfg(
1248 any(feature = "strict", feature = "ignore_duplicates")
1249 )]
1250 if _serde::__private::Option::is_some(&m_sideForce) {
1251 #[cfg(feature = "ignore_duplicates")]
1252 {
1253 __A::skip_value(&mut __map)?;
1254 continue;
1255 }
1256 #[cfg(feature = "strict")]
1257 return _serde::__private::Err(
1258 <__A::Error as _serde::de::Error>::duplicate_field(
1259 "sideForce",
1260 ),
1261 );
1262 }
1263 m_sideForce = _serde::__private::Some(
1264 match __A::next_value::<f32>(&mut __map) {
1265 _serde::__private::Ok(__val) => __val,
1266 _serde::__private::Err(__err) => {
1267 return _serde::__private::Err(__err);
1268 }
1269 },
1270 );
1271 }
1272 __Field::m_forwardSlipVelocity => {
1273 #[cfg(
1274 any(feature = "strict", feature = "ignore_duplicates")
1275 )]
1276 if _serde::__private::Option::is_some(
1277 &m_forwardSlipVelocity,
1278 ) {
1279 #[cfg(feature = "ignore_duplicates")]
1280 {
1281 __A::skip_value(&mut __map)?;
1282 continue;
1283 }
1284 #[cfg(feature = "strict")]
1285 return _serde::__private::Err(
1286 <__A::Error as _serde::de::Error>::duplicate_field(
1287 "forwardSlipVelocity",
1288 ),
1289 );
1290 }
1291 m_forwardSlipVelocity = _serde::__private::Some(
1292 match __A::next_value::<f32>(&mut __map) {
1293 _serde::__private::Ok(__val) => __val,
1294 _serde::__private::Err(__err) => {
1295 return _serde::__private::Err(__err);
1296 }
1297 },
1298 );
1299 }
1300 __Field::m_sideSlipVelocity => {
1301 #[cfg(
1302 any(feature = "strict", feature = "ignore_duplicates")
1303 )]
1304 if _serde::__private::Option::is_some(&m_sideSlipVelocity) {
1305 #[cfg(feature = "ignore_duplicates")]
1306 {
1307 __A::skip_value(&mut __map)?;
1308 continue;
1309 }
1310 #[cfg(feature = "strict")]
1311 return _serde::__private::Err(
1312 <__A::Error as _serde::de::Error>::duplicate_field(
1313 "sideSlipVelocity",
1314 ),
1315 );
1316 }
1317 m_sideSlipVelocity = _serde::__private::Some(
1318 match __A::next_value::<f32>(&mut __map) {
1319 _serde::__private::Ok(__val) => __val,
1320 _serde::__private::Err(__err) => {
1321 return _serde::__private::Err(__err);
1322 }
1323 },
1324 );
1325 }
1326 _ => __A::skip_value(&mut __map)?,
1327 }
1328 }
1329 let m_contactPoint = match m_contactPoint {
1330 _serde::__private::Some(__field) => __field,
1331 _serde::__private::None => {
1332 #[cfg(feature = "strict")]
1333 return _serde::__private::Err(
1334 <__A::Error as _serde::de::Error>::missing_field(
1335 "contactPoint",
1336 ),
1337 );
1338 #[cfg(not(feature = "strict"))] Default::default()
1339 }
1340 };
1341 let m_contactFriction = match m_contactFriction {
1342 _serde::__private::Some(__field) => __field,
1343 _serde::__private::None => {
1344 #[cfg(feature = "strict")]
1345 return _serde::__private::Err(
1346 <__A::Error as _serde::de::Error>::missing_field(
1347 "contactFriction",
1348 ),
1349 );
1350 #[cfg(not(feature = "strict"))] Default::default()
1351 }
1352 };
1353 let m_contactShapeKey = match m_contactShapeKey {
1354 _serde::__private::Some(__field) => __field,
1355 _serde::__private::None => {
1356 #[cfg(feature = "strict")]
1357 return _serde::__private::Err(
1358 <__A::Error as _serde::de::Error>::missing_field(
1359 "contactShapeKey",
1360 ),
1361 );
1362 #[cfg(not(feature = "strict"))] Default::default()
1363 }
1364 };
1365 let m_hardPointWs = match m_hardPointWs {
1366 _serde::__private::Some(__field) => __field,
1367 _serde::__private::None => {
1368 #[cfg(feature = "strict")]
1369 return _serde::__private::Err(
1370 <__A::Error as _serde::de::Error>::missing_field(
1371 "hardPointWs",
1372 ),
1373 );
1374 #[cfg(not(feature = "strict"))] Default::default()
1375 }
1376 };
1377 let m_rayEndPointWs = match m_rayEndPointWs {
1378 _serde::__private::Some(__field) => __field,
1379 _serde::__private::None => {
1380 #[cfg(feature = "strict")]
1381 return _serde::__private::Err(
1382 <__A::Error as _serde::de::Error>::missing_field(
1383 "rayEndPointWs",
1384 ),
1385 );
1386 #[cfg(not(feature = "strict"))] Default::default()
1387 }
1388 };
1389 let m_currentSuspensionLength = match m_currentSuspensionLength {
1390 _serde::__private::Some(__field) => __field,
1391 _serde::__private::None => {
1392 #[cfg(feature = "strict")]
1393 return _serde::__private::Err(
1394 <__A::Error as _serde::de::Error>::missing_field(
1395 "currentSuspensionLength",
1396 ),
1397 );
1398 #[cfg(not(feature = "strict"))] Default::default()
1399 }
1400 };
1401 let m_suspensionDirectionWs = match m_suspensionDirectionWs {
1402 _serde::__private::Some(__field) => __field,
1403 _serde::__private::None => {
1404 #[cfg(feature = "strict")]
1405 return _serde::__private::Err(
1406 <__A::Error as _serde::de::Error>::missing_field(
1407 "suspensionDirectionWs",
1408 ),
1409 );
1410 #[cfg(not(feature = "strict"))] Default::default()
1411 }
1412 };
1413 let m_spinAxisChassisSpace = match m_spinAxisChassisSpace {
1414 _serde::__private::Some(__field) => __field,
1415 _serde::__private::None => {
1416 #[cfg(feature = "strict")]
1417 return _serde::__private::Err(
1418 <__A::Error as _serde::de::Error>::missing_field(
1419 "spinAxisChassisSpace",
1420 ),
1421 );
1422 #[cfg(not(feature = "strict"))] Default::default()
1423 }
1424 };
1425 let m_spinAxisWs = match m_spinAxisWs {
1426 _serde::__private::Some(__field) => __field,
1427 _serde::__private::None => {
1428 #[cfg(feature = "strict")]
1429 return _serde::__private::Err(
1430 <__A::Error as _serde::de::Error>::missing_field(
1431 "spinAxisWs",
1432 ),
1433 );
1434 #[cfg(not(feature = "strict"))] Default::default()
1435 }
1436 };
1437 let m_steeringOrientationChassisSpace = match m_steeringOrientationChassisSpace {
1438 _serde::__private::Some(__field) => __field,
1439 _serde::__private::None => {
1440 #[cfg(feature = "strict")]
1441 return _serde::__private::Err(
1442 <__A::Error as _serde::de::Error>::missing_field(
1443 "steeringOrientationChassisSpace",
1444 ),
1445 );
1446 #[cfg(not(feature = "strict"))] Default::default()
1447 }
1448 };
1449 let m_spinVelocity = match m_spinVelocity {
1450 _serde::__private::Some(__field) => __field,
1451 _serde::__private::None => {
1452 #[cfg(feature = "strict")]
1453 return _serde::__private::Err(
1454 <__A::Error as _serde::de::Error>::missing_field(
1455 "spinVelocity",
1456 ),
1457 );
1458 #[cfg(not(feature = "strict"))] Default::default()
1459 }
1460 };
1461 let m_spinAngle = match m_spinAngle {
1462 _serde::__private::Some(__field) => __field,
1463 _serde::__private::None => {
1464 #[cfg(feature = "strict")]
1465 return _serde::__private::Err(
1466 <__A::Error as _serde::de::Error>::missing_field(
1467 "spinAngle",
1468 ),
1469 );
1470 #[cfg(not(feature = "strict"))] Default::default()
1471 }
1472 };
1473 let m_skidEnergyDensity = match m_skidEnergyDensity {
1474 _serde::__private::Some(__field) => __field,
1475 _serde::__private::None => {
1476 #[cfg(feature = "strict")]
1477 return _serde::__private::Err(
1478 <__A::Error as _serde::de::Error>::missing_field(
1479 "skidEnergyDensity",
1480 ),
1481 );
1482 #[cfg(not(feature = "strict"))] Default::default()
1483 }
1484 };
1485 let m_sideForce = match m_sideForce {
1486 _serde::__private::Some(__field) => __field,
1487 _serde::__private::None => {
1488 #[cfg(feature = "strict")]
1489 return _serde::__private::Err(
1490 <__A::Error as _serde::de::Error>::missing_field(
1491 "sideForce",
1492 ),
1493 );
1494 #[cfg(not(feature = "strict"))] Default::default()
1495 }
1496 };
1497 let m_forwardSlipVelocity = match m_forwardSlipVelocity {
1498 _serde::__private::Some(__field) => __field,
1499 _serde::__private::None => {
1500 #[cfg(feature = "strict")]
1501 return _serde::__private::Err(
1502 <__A::Error as _serde::de::Error>::missing_field(
1503 "forwardSlipVelocity",
1504 ),
1505 );
1506 #[cfg(not(feature = "strict"))] Default::default()
1507 }
1508 };
1509 let m_sideSlipVelocity = match m_sideSlipVelocity {
1510 _serde::__private::Some(__field) => __field,
1511 _serde::__private::None => {
1512 #[cfg(feature = "strict")]
1513 return _serde::__private::Err(
1514 <__A::Error as _serde::de::Error>::missing_field(
1515 "sideSlipVelocity",
1516 ),
1517 );
1518 #[cfg(not(feature = "strict"))] Default::default()
1519 }
1520 };
1521 let __ptr = __A::class_ptr(&mut __map);
1522 _serde::__private::Ok(hkpVehicleInstanceWheelInfo {
1523 __ptr,
1524 m_contactPoint,
1525 m_contactFriction,
1526 m_contactShapeKey,
1527 m_hardPointWs,
1528 m_rayEndPointWs,
1529 m_currentSuspensionLength,
1530 m_suspensionDirectionWs,
1531 m_spinAxisChassisSpace,
1532 m_spinAxisWs,
1533 m_steeringOrientationChassisSpace,
1534 m_spinVelocity,
1535 m_spinAngle,
1536 m_skidEnergyDensity,
1537 m_sideForce,
1538 m_forwardSlipVelocity,
1539 m_sideSlipVelocity,
1540 ..Default::default()
1541 })
1542 }
1543 }
1544 const FIELDS: &[&str] = &[
1545 "contactPoint",
1546 "contactFriction",
1547 "contactBody",
1548 "contactShapeKey",
1549 "hardPointWs",
1550 "rayEndPointWs",
1551 "currentSuspensionLength",
1552 "suspensionDirectionWs",
1553 "spinAxisChassisSpace",
1554 "spinAxisWs",
1555 "steeringOrientationChassisSpace",
1556 "spinVelocity",
1557 "spinAngle",
1558 "skidEnergyDensity",
1559 "sideForce",
1560 "forwardSlipVelocity",
1561 "sideSlipVelocity",
1562 ];
1563 _serde::Deserializer::deserialize_struct(
1564 deserializer,
1565 "hkpVehicleInstanceWheelInfo",
1566 FIELDS,
1567 __hkpVehicleInstanceWheelInfoVisitor {
1568 marker: _serde::__private::PhantomData::<
1569 hkpVehicleInstanceWheelInfo,
1570 >,
1571 lifetime: _serde::__private::PhantomData,
1572 },
1573 )
1574 }
1575 }
1576};