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