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