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