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