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 hkpWheelConstraintDataAtoms {
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 = "suspensionBase"))]
31 #[cfg_attr(feature = "serde", serde(rename = "suspensionBase"))]
32 pub m_suspensionBase: hkpSetLocalTransformsConstraintAtom,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "lin0Limit"))]
38 #[cfg_attr(feature = "serde", serde(rename = "lin0Limit"))]
39 pub m_lin0Limit: hkpLinLimitConstraintAtom,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "lin0Soft"))]
45 #[cfg_attr(feature = "serde", serde(rename = "lin0Soft"))]
46 pub m_lin0Soft: hkpLinSoftConstraintAtom,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "lin1"))]
52 #[cfg_attr(feature = "serde", serde(rename = "lin1"))]
53 pub m_lin1: hkpLinConstraintAtom,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "lin2"))]
59 #[cfg_attr(feature = "serde", serde(rename = "lin2"))]
60 pub m_lin2: hkpLinConstraintAtom,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "steeringBase"))]
66 #[cfg_attr(feature = "serde", serde(rename = "steeringBase"))]
67 pub m_steeringBase: hkpSetLocalRotationsConstraintAtom,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "2dAng"))]
73 #[cfg_attr(feature = "serde", serde(rename = "2dAng"))]
74 pub m_2dAng: hkp2dAngConstraintAtom,
75}
76const _: () = {
77 use havok_serde as _serde;
78 impl _serde::HavokClass for hkpWheelConstraintDataAtoms {
79 #[inline]
80 fn name(&self) -> &'static str {
81 "hkpWheelConstraintDataAtoms"
82 }
83 #[inline]
84 fn signature(&self) -> _serde::__private::Signature {
85 _serde::__private::Signature::new(0x1188cbe1)
86 }
87 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
88 fn deps_indexes(&self) -> Vec<usize> {
89 let mut v = Vec::new();
90 v.extend(self.m_suspensionBase.deps_indexes());
91 v.extend(self.m_lin0Limit.deps_indexes());
92 v.extend(self.m_lin0Soft.deps_indexes());
93 v.extend(self.m_lin1.deps_indexes());
94 v.extend(self.m_lin2.deps_indexes());
95 v.extend(self.m_steeringBase.deps_indexes());
96 v.extend(self.m_2dAng.deps_indexes());
97 v
98 }
99 }
100 impl _serde::Serialize for hkpWheelConstraintDataAtoms {
101 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
102 where
103 S: _serde::ser::Serializer,
104 {
105 let class_meta = self
106 .__ptr
107 .map(|name| (name, _serde::__private::Signature::new(0x1188cbe1)));
108 let mut serializer = __serializer
109 .serialize_struct(
110 "hkpWheelConstraintDataAtoms",
111 class_meta,
112 (304u64, 304u64),
113 )?;
114 serializer.serialize_field("suspensionBase", &self.m_suspensionBase)?;
115 serializer.serialize_field("lin0Limit", &self.m_lin0Limit)?;
116 serializer.serialize_field("lin0Soft", &self.m_lin0Soft)?;
117 serializer.serialize_field("lin1", &self.m_lin1)?;
118 serializer.serialize_field("lin2", &self.m_lin2)?;
119 serializer.serialize_field("steeringBase", &self.m_steeringBase)?;
120 serializer.serialize_field("2dAng", &self.m_2dAng)?;
121 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 12usize].as_slice())?;
122 serializer.end()
123 }
124 }
125};
126#[doc(hidden)]
127#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
128const _: () = {
129 use havok_serde as _serde;
130 #[automatically_derived]
131 impl<'de> _serde::Deserialize<'de> for hkpWheelConstraintDataAtoms {
132 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
133 where
134 __D: _serde::Deserializer<'de>,
135 {
136 #[allow(non_camel_case_types)]
137 enum __Field {
138 m_suspensionBase,
139 m_lin0Limit,
140 m_lin0Soft,
141 m_lin1,
142 m_lin2,
143 m_steeringBase,
144 m_2dAng,
145 __ignore,
146 }
147 struct __FieldVisitor;
148 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
149 type Value = __Field;
150 fn expecting(
151 &self,
152 __formatter: &mut core::fmt::Formatter,
153 ) -> core::fmt::Result {
154 core::fmt::Formatter::write_str(__formatter, "field identifier")
155 }
156 #[allow(clippy::match_single_binding)]
158 #[allow(clippy::reversed_empty_ranges)]
159 #[allow(clippy::single_match)]
160 fn visit_key<__E>(
161 self,
162 __value: &str,
163 ) -> core::result::Result<Self::Value, __E>
164 where
165 __E: _serde::de::Error,
166 {
167 match __value {
168 "suspensionBase" => Ok(__Field::m_suspensionBase),
169 "lin0Limit" => Ok(__Field::m_lin0Limit),
170 "lin0Soft" => Ok(__Field::m_lin0Soft),
171 "lin1" => Ok(__Field::m_lin1),
172 "lin2" => Ok(__Field::m_lin2),
173 "steeringBase" => Ok(__Field::m_steeringBase),
174 "2dAng" => Ok(__Field::m_2dAng),
175 _ => Ok(__Field::__ignore),
176 }
177 }
178 }
179 impl<'de> _serde::Deserialize<'de> for __Field {
180 #[inline]
181 fn deserialize<__D>(
182 __deserializer: __D,
183 ) -> core::result::Result<Self, __D::Error>
184 where
185 __D: _serde::Deserializer<'de>,
186 {
187 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
188 }
189 }
190 struct __hkpWheelConstraintDataAtomsVisitor<'de> {
191 marker: _serde::__private::PhantomData<hkpWheelConstraintDataAtoms>,
192 lifetime: _serde::__private::PhantomData<&'de ()>,
193 }
194 #[allow(clippy::match_single_binding)]
195 #[allow(clippy::reversed_empty_ranges)]
196 #[allow(clippy::single_match)]
197 impl<'de> _serde::de::Visitor<'de>
198 for __hkpWheelConstraintDataAtomsVisitor<'de> {
199 type Value = hkpWheelConstraintDataAtoms;
200 fn expecting(
201 &self,
202 __formatter: &mut core::fmt::Formatter,
203 ) -> core::fmt::Result {
204 core::fmt::Formatter::write_str(
205 __formatter,
206 "struct hkpWheelConstraintDataAtoms",
207 )
208 }
209 fn visit_struct_for_bytes<__A>(
210 self,
211 mut __map: __A,
212 ) -> _serde::__private::Result<Self::Value, __A::Error>
213 where
214 __A: _serde::de::MapAccess<'de>,
215 {
216 let __ptr = __A::class_ptr(&mut __map);
217 let mut m_suspensionBase: _serde::__private::Option<
218 hkpSetLocalTransformsConstraintAtom,
219 > = _serde::__private::None;
220 let mut m_lin0Limit: _serde::__private::Option<
221 hkpLinLimitConstraintAtom,
222 > = _serde::__private::None;
223 let mut m_lin0Soft: _serde::__private::Option<
224 hkpLinSoftConstraintAtom,
225 > = _serde::__private::None;
226 let mut m_lin1: _serde::__private::Option<hkpLinConstraintAtom> = _serde::__private::None;
227 let mut m_lin2: _serde::__private::Option<hkpLinConstraintAtom> = _serde::__private::None;
228 let mut m_steeringBase: _serde::__private::Option<
229 hkpSetLocalRotationsConstraintAtom,
230 > = _serde::__private::None;
231 let mut m_2dAng: _serde::__private::Option<hkp2dAngConstraintAtom> = _serde::__private::None;
232 for i in 0..7usize {
233 match i {
234 0usize => {
235 if _serde::__private::Option::is_some(&m_suspensionBase) {
236 return _serde::__private::Err(
237 <__A::Error as _serde::de::Error>::duplicate_field(
238 "suspensionBase",
239 ),
240 );
241 }
242 m_suspensionBase = _serde::__private::Some(
243 match __A::next_value::<
244 hkpSetLocalTransformsConstraintAtom,
245 >(&mut __map) {
246 _serde::__private::Ok(__val) => __val,
247 _serde::__private::Err(__err) => {
248 return _serde::__private::Err(__err);
249 }
250 },
251 );
252 }
253 1usize => {
254 if _serde::__private::Option::is_some(&m_lin0Limit) {
255 return _serde::__private::Err(
256 <__A::Error as _serde::de::Error>::duplicate_field(
257 "lin0Limit",
258 ),
259 );
260 }
261 m_lin0Limit = _serde::__private::Some(
262 match __A::next_value::<
263 hkpLinLimitConstraintAtom,
264 >(&mut __map) {
265 _serde::__private::Ok(__val) => __val,
266 _serde::__private::Err(__err) => {
267 return _serde::__private::Err(__err);
268 }
269 },
270 );
271 }
272 2usize => {
273 if _serde::__private::Option::is_some(&m_lin0Soft) {
274 return _serde::__private::Err(
275 <__A::Error as _serde::de::Error>::duplicate_field(
276 "lin0Soft",
277 ),
278 );
279 }
280 m_lin0Soft = _serde::__private::Some(
281 match __A::next_value::<
282 hkpLinSoftConstraintAtom,
283 >(&mut __map) {
284 _serde::__private::Ok(__val) => __val,
285 _serde::__private::Err(__err) => {
286 return _serde::__private::Err(__err);
287 }
288 },
289 );
290 }
291 3usize => {
292 if _serde::__private::Option::is_some(&m_lin1) {
293 return _serde::__private::Err(
294 <__A::Error as _serde::de::Error>::duplicate_field("lin1"),
295 );
296 }
297 m_lin1 = _serde::__private::Some(
298 match __A::next_value::<hkpLinConstraintAtom>(&mut __map) {
299 _serde::__private::Ok(__val) => __val,
300 _serde::__private::Err(__err) => {
301 return _serde::__private::Err(__err);
302 }
303 },
304 );
305 }
306 4usize => {
307 if _serde::__private::Option::is_some(&m_lin2) {
308 return _serde::__private::Err(
309 <__A::Error as _serde::de::Error>::duplicate_field("lin2"),
310 );
311 }
312 m_lin2 = _serde::__private::Some(
313 match __A::next_value::<hkpLinConstraintAtom>(&mut __map) {
314 _serde::__private::Ok(__val) => __val,
315 _serde::__private::Err(__err) => {
316 return _serde::__private::Err(__err);
317 }
318 },
319 );
320 }
321 5usize => {
322 if _serde::__private::Option::is_some(&m_steeringBase) {
323 return _serde::__private::Err(
324 <__A::Error as _serde::de::Error>::duplicate_field(
325 "steeringBase",
326 ),
327 );
328 }
329 m_steeringBase = _serde::__private::Some(
330 match __A::next_value::<
331 hkpSetLocalRotationsConstraintAtom,
332 >(&mut __map) {
333 _serde::__private::Ok(__val) => __val,
334 _serde::__private::Err(__err) => {
335 return _serde::__private::Err(__err);
336 }
337 },
338 );
339 }
340 6usize => {
341 if _serde::__private::Option::is_some(&m_2dAng) {
342 return _serde::__private::Err(
343 <__A::Error as _serde::de::Error>::duplicate_field("2dAng"),
344 );
345 }
346 m_2dAng = _serde::__private::Some(
347 match __A::next_value::<
348 hkp2dAngConstraintAtom,
349 >(&mut __map) {
350 _serde::__private::Ok(__val) => __val,
351 _serde::__private::Err(__err) => {
352 return _serde::__private::Err(__err);
353 }
354 },
355 );
356 }
357 _ => {}
358 }
359 }
360 __A::pad(&mut __map, 12usize, 12usize)?;
361 let m_suspensionBase = match m_suspensionBase {
362 _serde::__private::Some(__field) => __field,
363 _serde::__private::None => {
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::missing_field(
366 "suspensionBase",
367 ),
368 );
369 }
370 };
371 let m_lin0Limit = match m_lin0Limit {
372 _serde::__private::Some(__field) => __field,
373 _serde::__private::None => {
374 return _serde::__private::Err(
375 <__A::Error as _serde::de::Error>::missing_field(
376 "lin0Limit",
377 ),
378 );
379 }
380 };
381 let m_lin0Soft = match m_lin0Soft {
382 _serde::__private::Some(__field) => __field,
383 _serde::__private::None => {
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::missing_field("lin0Soft"),
386 );
387 }
388 };
389 let m_lin1 = match m_lin1 {
390 _serde::__private::Some(__field) => __field,
391 _serde::__private::None => {
392 return _serde::__private::Err(
393 <__A::Error as _serde::de::Error>::missing_field("lin1"),
394 );
395 }
396 };
397 let m_lin2 = match m_lin2 {
398 _serde::__private::Some(__field) => __field,
399 _serde::__private::None => {
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::missing_field("lin2"),
402 );
403 }
404 };
405 let m_steeringBase = match m_steeringBase {
406 _serde::__private::Some(__field) => __field,
407 _serde::__private::None => {
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::missing_field(
410 "steeringBase",
411 ),
412 );
413 }
414 };
415 let m_2dAng = match m_2dAng {
416 _serde::__private::Some(__field) => __field,
417 _serde::__private::None => {
418 return _serde::__private::Err(
419 <__A::Error as _serde::de::Error>::missing_field("2dAng"),
420 );
421 }
422 };
423 _serde::__private::Ok(hkpWheelConstraintDataAtoms {
424 __ptr,
425 m_suspensionBase,
426 m_lin0Limit,
427 m_lin0Soft,
428 m_lin1,
429 m_lin2,
430 m_steeringBase,
431 m_2dAng,
432 })
433 }
434 #[allow(clippy::manual_unwrap_or_default)]
435 fn visit_struct<__A>(
436 self,
437 mut __map: __A,
438 ) -> _serde::__private::Result<Self::Value, __A::Error>
439 where
440 __A: _serde::de::MapAccess<'de>,
441 {
442 let mut m_suspensionBase: _serde::__private::Option<
443 hkpSetLocalTransformsConstraintAtom,
444 > = _serde::__private::None;
445 let mut m_lin0Limit: _serde::__private::Option<
446 hkpLinLimitConstraintAtom,
447 > = _serde::__private::None;
448 let mut m_lin0Soft: _serde::__private::Option<
449 hkpLinSoftConstraintAtom,
450 > = _serde::__private::None;
451 let mut m_lin1: _serde::__private::Option<hkpLinConstraintAtom> = _serde::__private::None;
452 let mut m_lin2: _serde::__private::Option<hkpLinConstraintAtom> = _serde::__private::None;
453 let mut m_steeringBase: _serde::__private::Option<
454 hkpSetLocalRotationsConstraintAtom,
455 > = _serde::__private::None;
456 let mut m_2dAng: _serde::__private::Option<hkp2dAngConstraintAtom> = _serde::__private::None;
457 while let _serde::__private::Some(__key) = {
458 __A::next_key::<__Field>(&mut __map)?
459 } {
460 match __key {
461 __Field::m_suspensionBase => {
462 #[cfg(
463 any(feature = "strict", feature = "ignore_duplicates")
464 )]
465 if _serde::__private::Option::is_some(&m_suspensionBase) {
466 #[cfg(feature = "ignore_duplicates")]
467 {
468 __A::skip_value(&mut __map)?;
469 continue;
470 }
471 #[cfg(feature = "strict")]
472 return _serde::__private::Err(
473 <__A::Error as _serde::de::Error>::duplicate_field(
474 "suspensionBase",
475 ),
476 );
477 }
478 m_suspensionBase = _serde::__private::Some(
479 match __A::next_value::<
480 hkpSetLocalTransformsConstraintAtom,
481 >(&mut __map) {
482 _serde::__private::Ok(__val) => __val,
483 _serde::__private::Err(__err) => {
484 return _serde::__private::Err(__err);
485 }
486 },
487 );
488 }
489 __Field::m_lin0Limit => {
490 #[cfg(
491 any(feature = "strict", feature = "ignore_duplicates")
492 )]
493 if _serde::__private::Option::is_some(&m_lin0Limit) {
494 #[cfg(feature = "ignore_duplicates")]
495 {
496 __A::skip_value(&mut __map)?;
497 continue;
498 }
499 #[cfg(feature = "strict")]
500 return _serde::__private::Err(
501 <__A::Error as _serde::de::Error>::duplicate_field(
502 "lin0Limit",
503 ),
504 );
505 }
506 m_lin0Limit = _serde::__private::Some(
507 match __A::next_value::<
508 hkpLinLimitConstraintAtom,
509 >(&mut __map) {
510 _serde::__private::Ok(__val) => __val,
511 _serde::__private::Err(__err) => {
512 return _serde::__private::Err(__err);
513 }
514 },
515 );
516 }
517 __Field::m_lin0Soft => {
518 #[cfg(
519 any(feature = "strict", feature = "ignore_duplicates")
520 )]
521 if _serde::__private::Option::is_some(&m_lin0Soft) {
522 #[cfg(feature = "ignore_duplicates")]
523 {
524 __A::skip_value(&mut __map)?;
525 continue;
526 }
527 #[cfg(feature = "strict")]
528 return _serde::__private::Err(
529 <__A::Error as _serde::de::Error>::duplicate_field(
530 "lin0Soft",
531 ),
532 );
533 }
534 m_lin0Soft = _serde::__private::Some(
535 match __A::next_value::<
536 hkpLinSoftConstraintAtom,
537 >(&mut __map) {
538 _serde::__private::Ok(__val) => __val,
539 _serde::__private::Err(__err) => {
540 return _serde::__private::Err(__err);
541 }
542 },
543 );
544 }
545 __Field::m_lin1 => {
546 #[cfg(
547 any(feature = "strict", feature = "ignore_duplicates")
548 )]
549 if _serde::__private::Option::is_some(&m_lin1) {
550 #[cfg(feature = "ignore_duplicates")]
551 {
552 __A::skip_value(&mut __map)?;
553 continue;
554 }
555 #[cfg(feature = "strict")]
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::duplicate_field("lin1"),
558 );
559 }
560 m_lin1 = _serde::__private::Some(
561 match __A::next_value::<hkpLinConstraintAtom>(&mut __map) {
562 _serde::__private::Ok(__val) => __val,
563 _serde::__private::Err(__err) => {
564 return _serde::__private::Err(__err);
565 }
566 },
567 );
568 }
569 __Field::m_lin2 => {
570 #[cfg(
571 any(feature = "strict", feature = "ignore_duplicates")
572 )]
573 if _serde::__private::Option::is_some(&m_lin2) {
574 #[cfg(feature = "ignore_duplicates")]
575 {
576 __A::skip_value(&mut __map)?;
577 continue;
578 }
579 #[cfg(feature = "strict")]
580 return _serde::__private::Err(
581 <__A::Error as _serde::de::Error>::duplicate_field("lin2"),
582 );
583 }
584 m_lin2 = _serde::__private::Some(
585 match __A::next_value::<hkpLinConstraintAtom>(&mut __map) {
586 _serde::__private::Ok(__val) => __val,
587 _serde::__private::Err(__err) => {
588 return _serde::__private::Err(__err);
589 }
590 },
591 );
592 }
593 __Field::m_steeringBase => {
594 #[cfg(
595 any(feature = "strict", feature = "ignore_duplicates")
596 )]
597 if _serde::__private::Option::is_some(&m_steeringBase) {
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 "steeringBase",
607 ),
608 );
609 }
610 m_steeringBase = _serde::__private::Some(
611 match __A::next_value::<
612 hkpSetLocalRotationsConstraintAtom,
613 >(&mut __map) {
614 _serde::__private::Ok(__val) => __val,
615 _serde::__private::Err(__err) => {
616 return _serde::__private::Err(__err);
617 }
618 },
619 );
620 }
621 __Field::m_2dAng => {
622 #[cfg(
623 any(feature = "strict", feature = "ignore_duplicates")
624 )]
625 if _serde::__private::Option::is_some(&m_2dAng) {
626 #[cfg(feature = "ignore_duplicates")]
627 {
628 __A::skip_value(&mut __map)?;
629 continue;
630 }
631 #[cfg(feature = "strict")]
632 return _serde::__private::Err(
633 <__A::Error as _serde::de::Error>::duplicate_field("2dAng"),
634 );
635 }
636 m_2dAng = _serde::__private::Some(
637 match __A::next_value::<
638 hkp2dAngConstraintAtom,
639 >(&mut __map) {
640 _serde::__private::Ok(__val) => __val,
641 _serde::__private::Err(__err) => {
642 return _serde::__private::Err(__err);
643 }
644 },
645 );
646 }
647 _ => __A::skip_value(&mut __map)?,
648 }
649 }
650 let m_suspensionBase = match m_suspensionBase {
651 _serde::__private::Some(__field) => __field,
652 _serde::__private::None => {
653 #[cfg(feature = "strict")]
654 return _serde::__private::Err(
655 <__A::Error as _serde::de::Error>::missing_field(
656 "suspensionBase",
657 ),
658 );
659 #[cfg(not(feature = "strict"))] Default::default()
660 }
661 };
662 let m_lin0Limit = match m_lin0Limit {
663 _serde::__private::Some(__field) => __field,
664 _serde::__private::None => {
665 #[cfg(feature = "strict")]
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::missing_field(
668 "lin0Limit",
669 ),
670 );
671 #[cfg(not(feature = "strict"))] Default::default()
672 }
673 };
674 let m_lin0Soft = match m_lin0Soft {
675 _serde::__private::Some(__field) => __field,
676 _serde::__private::None => {
677 #[cfg(feature = "strict")]
678 return _serde::__private::Err(
679 <__A::Error as _serde::de::Error>::missing_field("lin0Soft"),
680 );
681 #[cfg(not(feature = "strict"))] Default::default()
682 }
683 };
684 let m_lin1 = match m_lin1 {
685 _serde::__private::Some(__field) => __field,
686 _serde::__private::None => {
687 #[cfg(feature = "strict")]
688 return _serde::__private::Err(
689 <__A::Error as _serde::de::Error>::missing_field("lin1"),
690 );
691 #[cfg(not(feature = "strict"))] Default::default()
692 }
693 };
694 let m_lin2 = match m_lin2 {
695 _serde::__private::Some(__field) => __field,
696 _serde::__private::None => {
697 #[cfg(feature = "strict")]
698 return _serde::__private::Err(
699 <__A::Error as _serde::de::Error>::missing_field("lin2"),
700 );
701 #[cfg(not(feature = "strict"))] Default::default()
702 }
703 };
704 let m_steeringBase = match m_steeringBase {
705 _serde::__private::Some(__field) => __field,
706 _serde::__private::None => {
707 #[cfg(feature = "strict")]
708 return _serde::__private::Err(
709 <__A::Error as _serde::de::Error>::missing_field(
710 "steeringBase",
711 ),
712 );
713 #[cfg(not(feature = "strict"))] Default::default()
714 }
715 };
716 let m_2dAng = match m_2dAng {
717 _serde::__private::Some(__field) => __field,
718 _serde::__private::None => {
719 #[cfg(feature = "strict")]
720 return _serde::__private::Err(
721 <__A::Error as _serde::de::Error>::missing_field("2dAng"),
722 );
723 #[cfg(not(feature = "strict"))] Default::default()
724 }
725 };
726 let __ptr = __A::class_ptr(&mut __map);
727 _serde::__private::Ok(hkpWheelConstraintDataAtoms {
728 __ptr,
729 m_suspensionBase,
730 m_lin0Limit,
731 m_lin0Soft,
732 m_lin1,
733 m_lin2,
734 m_steeringBase,
735 m_2dAng,
736 })
737 }
738 }
739 const FIELDS: &[&str] = &[
740 "suspensionBase",
741 "lin0Limit",
742 "lin0Soft",
743 "lin1",
744 "lin2",
745 "steeringBase",
746 "2dAng",
747 ];
748 _serde::Deserializer::deserialize_struct(
749 deserializer,
750 "hkpWheelConstraintDataAtoms",
751 FIELDS,
752 __hkpWheelConstraintDataAtomsVisitor {
753 marker: _serde::__private::PhantomData::<
754 hkpWheelConstraintDataAtoms,
755 >,
756 lifetime: _serde::__private::PhantomData,
757 },
758 )
759 }
760 }
761};