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