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