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