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