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 hkbAttachmentSetup {
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: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "blendInTime"))]
35 #[cfg_attr(feature = "serde", serde(rename = "blendInTime"))]
36 pub m_blendInTime: f32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "moveAttacherFraction"))]
42 #[cfg_attr(feature = "serde", serde(rename = "moveAttacherFraction"))]
43 pub m_moveAttacherFraction: f32,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "gain"))]
49 #[cfg_attr(feature = "serde", serde(rename = "gain"))]
50 pub m_gain: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "extrapolationTimeStep"))]
56 #[cfg_attr(feature = "serde", serde(rename = "extrapolationTimeStep"))]
57 pub m_extrapolationTimeStep: f32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "fixUpGain"))]
63 #[cfg_attr(feature = "serde", serde(rename = "fixUpGain"))]
64 pub m_fixUpGain: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "maxLinearDistance"))]
70 #[cfg_attr(feature = "serde", serde(rename = "maxLinearDistance"))]
71 pub m_maxLinearDistance: f32,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "maxAngularDistance"))]
77 #[cfg_attr(feature = "serde", serde(rename = "maxAngularDistance"))]
78 pub m_maxAngularDistance: f32,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "attachmentType"))]
84 #[cfg_attr(feature = "serde", serde(rename = "attachmentType"))]
85 pub m_attachmentType: AttachmentType,
86}
87const _: () = {
88 use havok_serde as _serde;
89 impl _serde::HavokClass for hkbAttachmentSetup {
90 #[inline]
91 fn name(&self) -> &'static str {
92 "hkbAttachmentSetup"
93 }
94 #[inline]
95 fn signature(&self) -> _serde::__private::Signature {
96 _serde::__private::Signature::new(0x774632b)
97 }
98 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
99 fn deps_indexes(&self) -> Vec<usize> {
100 let mut v = Vec::new();
101 v
102 }
103 }
104 impl _serde::Serialize for hkbAttachmentSetup {
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(0x774632b)));
112 let mut serializer = __serializer
113 .serialize_struct("hkbAttachmentSetup", class_meta, (40u64, 48u64))?;
114 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
115 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
116 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer.serialize_field("blendInTime", &self.m_blendInTime)?;
119 serializer
120 .serialize_field("moveAttacherFraction", &self.m_moveAttacherFraction)?;
121 serializer.serialize_field("gain", &self.m_gain)?;
122 serializer
123 .serialize_field(
124 "extrapolationTimeStep",
125 &self.m_extrapolationTimeStep,
126 )?;
127 serializer.serialize_field("fixUpGain", &self.m_fixUpGain)?;
128 serializer.serialize_field("maxLinearDistance", &self.m_maxLinearDistance)?;
129 serializer
130 .serialize_field("maxAngularDistance", &self.m_maxAngularDistance)?;
131 serializer.serialize_field("attachmentType", &self.m_attachmentType)?;
132 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
133 serializer.end()
134 }
135 }
136};
137#[doc(hidden)]
138#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
139const _: () = {
140 use havok_serde as _serde;
141 #[automatically_derived]
142 impl<'de> _serde::Deserialize<'de> for hkbAttachmentSetup {
143 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
144 where
145 __D: _serde::Deserializer<'de>,
146 {
147 #[allow(non_camel_case_types)]
148 enum __Field {
149 m_blendInTime,
150 m_moveAttacherFraction,
151 m_gain,
152 m_extrapolationTimeStep,
153 m_fixUpGain,
154 m_maxLinearDistance,
155 m_maxAngularDistance,
156 m_attachmentType,
157 __ignore,
158 }
159 struct __FieldVisitor;
160 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
161 type Value = __Field;
162 fn expecting(
163 &self,
164 __formatter: &mut core::fmt::Formatter,
165 ) -> core::fmt::Result {
166 core::fmt::Formatter::write_str(__formatter, "field identifier")
167 }
168 #[allow(clippy::match_single_binding)]
170 #[allow(clippy::reversed_empty_ranges)]
171 #[allow(clippy::single_match)]
172 fn visit_key<__E>(
173 self,
174 __value: &str,
175 ) -> core::result::Result<Self::Value, __E>
176 where
177 __E: _serde::de::Error,
178 {
179 match __value {
180 "blendInTime" => Ok(__Field::m_blendInTime),
181 "moveAttacherFraction" => Ok(__Field::m_moveAttacherFraction),
182 "gain" => Ok(__Field::m_gain),
183 "extrapolationTimeStep" => Ok(__Field::m_extrapolationTimeStep),
184 "fixUpGain" => Ok(__Field::m_fixUpGain),
185 "maxLinearDistance" => Ok(__Field::m_maxLinearDistance),
186 "maxAngularDistance" => Ok(__Field::m_maxAngularDistance),
187 "attachmentType" => Ok(__Field::m_attachmentType),
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 __hkbAttachmentSetupVisitor<'de> {
204 marker: _serde::__private::PhantomData<hkbAttachmentSetup>,
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 __hkbAttachmentSetupVisitor<'de> {
211 type Value = hkbAttachmentSetup;
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 hkbAttachmentSetup",
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_blendInTime: _serde::__private::Option<f32> = _serde::__private::None;
231 let mut m_moveAttacherFraction: _serde::__private::Option<f32> = _serde::__private::None;
232 let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
233 let mut m_extrapolationTimeStep: _serde::__private::Option<f32> = _serde::__private::None;
234 let mut m_fixUpGain: _serde::__private::Option<f32> = _serde::__private::None;
235 let mut m_maxLinearDistance: _serde::__private::Option<f32> = _serde::__private::None;
236 let mut m_maxAngularDistance: _serde::__private::Option<f32> = _serde::__private::None;
237 let mut m_attachmentType: _serde::__private::Option<
238 AttachmentType,
239 > = _serde::__private::None;
240 for i in 0..8usize {
241 match i {
242 0usize => {
243 if _serde::__private::Option::is_some(&m_blendInTime) {
244 return _serde::__private::Err(
245 <__A::Error as _serde::de::Error>::duplicate_field(
246 "blendInTime",
247 ),
248 );
249 }
250 m_blendInTime = _serde::__private::Some(
251 match __A::next_value::<f32>(&mut __map) {
252 _serde::__private::Ok(__val) => __val,
253 _serde::__private::Err(__err) => {
254 return _serde::__private::Err(__err);
255 }
256 },
257 );
258 }
259 1usize => {
260 if _serde::__private::Option::is_some(
261 &m_moveAttacherFraction,
262 ) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "moveAttacherFraction",
266 ),
267 );
268 }
269 m_moveAttacherFraction = _serde::__private::Some(
270 match __A::next_value::<f32>(&mut __map) {
271 _serde::__private::Ok(__val) => __val,
272 _serde::__private::Err(__err) => {
273 return _serde::__private::Err(__err);
274 }
275 },
276 );
277 }
278 2usize => {
279 if _serde::__private::Option::is_some(&m_gain) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field("gain"),
282 );
283 }
284 m_gain = _serde::__private::Some(
285 match __A::next_value::<f32>(&mut __map) {
286 _serde::__private::Ok(__val) => __val,
287 _serde::__private::Err(__err) => {
288 return _serde::__private::Err(__err);
289 }
290 },
291 );
292 }
293 3usize => {
294 if _serde::__private::Option::is_some(
295 &m_extrapolationTimeStep,
296 ) {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "extrapolationTimeStep",
300 ),
301 );
302 }
303 m_extrapolationTimeStep = _serde::__private::Some(
304 match __A::next_value::<f32>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 4usize => {
313 if _serde::__private::Option::is_some(&m_fixUpGain) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field(
316 "fixUpGain",
317 ),
318 );
319 }
320 m_fixUpGain = _serde::__private::Some(
321 match __A::next_value::<f32>(&mut __map) {
322 _serde::__private::Ok(__val) => __val,
323 _serde::__private::Err(__err) => {
324 return _serde::__private::Err(__err);
325 }
326 },
327 );
328 }
329 5usize => {
330 if _serde::__private::Option::is_some(
331 &m_maxLinearDistance,
332 ) {
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::duplicate_field(
335 "maxLinearDistance",
336 ),
337 );
338 }
339 m_maxLinearDistance = _serde::__private::Some(
340 match __A::next_value::<f32>(&mut __map) {
341 _serde::__private::Ok(__val) => __val,
342 _serde::__private::Err(__err) => {
343 return _serde::__private::Err(__err);
344 }
345 },
346 );
347 }
348 6usize => {
349 if _serde::__private::Option::is_some(
350 &m_maxAngularDistance,
351 ) {
352 return _serde::__private::Err(
353 <__A::Error as _serde::de::Error>::duplicate_field(
354 "maxAngularDistance",
355 ),
356 );
357 }
358 m_maxAngularDistance = _serde::__private::Some(
359 match __A::next_value::<f32>(&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(&m_attachmentType) {
369 return _serde::__private::Err(
370 <__A::Error as _serde::de::Error>::duplicate_field(
371 "attachmentType",
372 ),
373 );
374 }
375 m_attachmentType = _serde::__private::Some(
376 match __A::next_value::<AttachmentType>(&mut __map) {
377 _serde::__private::Ok(__val) => __val,
378 _serde::__private::Err(__err) => {
379 return _serde::__private::Err(__err);
380 }
381 },
382 );
383 }
384 _ => {}
385 }
386 }
387 __A::pad(&mut __map, 3usize, 3usize)?;
388 let m_blendInTime = match m_blendInTime {
389 _serde::__private::Some(__field) => __field,
390 _serde::__private::None => {
391 return _serde::__private::Err(
392 <__A::Error as _serde::de::Error>::missing_field(
393 "blendInTime",
394 ),
395 );
396 }
397 };
398 let m_moveAttacherFraction = match m_moveAttacherFraction {
399 _serde::__private::Some(__field) => __field,
400 _serde::__private::None => {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::missing_field(
403 "moveAttacherFraction",
404 ),
405 );
406 }
407 };
408 let m_gain = match m_gain {
409 _serde::__private::Some(__field) => __field,
410 _serde::__private::None => {
411 return _serde::__private::Err(
412 <__A::Error as _serde::de::Error>::missing_field("gain"),
413 );
414 }
415 };
416 let m_extrapolationTimeStep = match m_extrapolationTimeStep {
417 _serde::__private::Some(__field) => __field,
418 _serde::__private::None => {
419 return _serde::__private::Err(
420 <__A::Error as _serde::de::Error>::missing_field(
421 "extrapolationTimeStep",
422 ),
423 );
424 }
425 };
426 let m_fixUpGain = match m_fixUpGain {
427 _serde::__private::Some(__field) => __field,
428 _serde::__private::None => {
429 return _serde::__private::Err(
430 <__A::Error as _serde::de::Error>::missing_field(
431 "fixUpGain",
432 ),
433 );
434 }
435 };
436 let m_maxLinearDistance = match m_maxLinearDistance {
437 _serde::__private::Some(__field) => __field,
438 _serde::__private::None => {
439 return _serde::__private::Err(
440 <__A::Error as _serde::de::Error>::missing_field(
441 "maxLinearDistance",
442 ),
443 );
444 }
445 };
446 let m_maxAngularDistance = match m_maxAngularDistance {
447 _serde::__private::Some(__field) => __field,
448 _serde::__private::None => {
449 return _serde::__private::Err(
450 <__A::Error as _serde::de::Error>::missing_field(
451 "maxAngularDistance",
452 ),
453 );
454 }
455 };
456 let m_attachmentType = match m_attachmentType {
457 _serde::__private::Some(__field) => __field,
458 _serde::__private::None => {
459 return _serde::__private::Err(
460 <__A::Error as _serde::de::Error>::missing_field(
461 "attachmentType",
462 ),
463 );
464 }
465 };
466 _serde::__private::Ok(hkbAttachmentSetup {
467 __ptr,
468 parent,
469 m_blendInTime,
470 m_moveAttacherFraction,
471 m_gain,
472 m_extrapolationTimeStep,
473 m_fixUpGain,
474 m_maxLinearDistance,
475 m_maxAngularDistance,
476 m_attachmentType,
477 })
478 }
479 #[allow(clippy::manual_unwrap_or_default)]
480 fn visit_struct<__A>(
481 self,
482 mut __map: __A,
483 ) -> _serde::__private::Result<Self::Value, __A::Error>
484 where
485 __A: _serde::de::MapAccess<'de>,
486 {
487 let mut m_blendInTime: _serde::__private::Option<f32> = _serde::__private::None;
488 let mut m_moveAttacherFraction: _serde::__private::Option<f32> = _serde::__private::None;
489 let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
490 let mut m_extrapolationTimeStep: _serde::__private::Option<f32> = _serde::__private::None;
491 let mut m_fixUpGain: _serde::__private::Option<f32> = _serde::__private::None;
492 let mut m_maxLinearDistance: _serde::__private::Option<f32> = _serde::__private::None;
493 let mut m_maxAngularDistance: _serde::__private::Option<f32> = _serde::__private::None;
494 let mut m_attachmentType: _serde::__private::Option<
495 AttachmentType,
496 > = _serde::__private::None;
497 while let _serde::__private::Some(__key) = {
498 __A::next_key::<__Field>(&mut __map)?
499 } {
500 match __key {
501 __Field::m_blendInTime => {
502 #[cfg(
503 any(feature = "strict", feature = "ignore_duplicates")
504 )]
505 if _serde::__private::Option::is_some(&m_blendInTime) {
506 #[cfg(feature = "ignore_duplicates")]
507 {
508 __A::skip_value(&mut __map)?;
509 continue;
510 }
511 #[cfg(feature = "strict")]
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::duplicate_field(
514 "blendInTime",
515 ),
516 );
517 }
518 m_blendInTime = _serde::__private::Some(
519 match __A::next_value::<f32>(&mut __map) {
520 _serde::__private::Ok(__val) => __val,
521 _serde::__private::Err(__err) => {
522 return _serde::__private::Err(__err);
523 }
524 },
525 );
526 }
527 __Field::m_moveAttacherFraction => {
528 #[cfg(
529 any(feature = "strict", feature = "ignore_duplicates")
530 )]
531 if _serde::__private::Option::is_some(
532 &m_moveAttacherFraction,
533 ) {
534 #[cfg(feature = "ignore_duplicates")]
535 {
536 __A::skip_value(&mut __map)?;
537 continue;
538 }
539 #[cfg(feature = "strict")]
540 return _serde::__private::Err(
541 <__A::Error as _serde::de::Error>::duplicate_field(
542 "moveAttacherFraction",
543 ),
544 );
545 }
546 m_moveAttacherFraction = _serde::__private::Some(
547 match __A::next_value::<f32>(&mut __map) {
548 _serde::__private::Ok(__val) => __val,
549 _serde::__private::Err(__err) => {
550 return _serde::__private::Err(__err);
551 }
552 },
553 );
554 }
555 __Field::m_gain => {
556 #[cfg(
557 any(feature = "strict", feature = "ignore_duplicates")
558 )]
559 if _serde::__private::Option::is_some(&m_gain) {
560 #[cfg(feature = "ignore_duplicates")]
561 {
562 __A::skip_value(&mut __map)?;
563 continue;
564 }
565 #[cfg(feature = "strict")]
566 return _serde::__private::Err(
567 <__A::Error as _serde::de::Error>::duplicate_field("gain"),
568 );
569 }
570 m_gain = _serde::__private::Some(
571 match __A::next_value::<f32>(&mut __map) {
572 _serde::__private::Ok(__val) => __val,
573 _serde::__private::Err(__err) => {
574 return _serde::__private::Err(__err);
575 }
576 },
577 );
578 }
579 __Field::m_extrapolationTimeStep => {
580 #[cfg(
581 any(feature = "strict", feature = "ignore_duplicates")
582 )]
583 if _serde::__private::Option::is_some(
584 &m_extrapolationTimeStep,
585 ) {
586 #[cfg(feature = "ignore_duplicates")]
587 {
588 __A::skip_value(&mut __map)?;
589 continue;
590 }
591 #[cfg(feature = "strict")]
592 return _serde::__private::Err(
593 <__A::Error as _serde::de::Error>::duplicate_field(
594 "extrapolationTimeStep",
595 ),
596 );
597 }
598 m_extrapolationTimeStep = _serde::__private::Some(
599 match __A::next_value::<f32>(&mut __map) {
600 _serde::__private::Ok(__val) => __val,
601 _serde::__private::Err(__err) => {
602 return _serde::__private::Err(__err);
603 }
604 },
605 );
606 }
607 __Field::m_fixUpGain => {
608 #[cfg(
609 any(feature = "strict", feature = "ignore_duplicates")
610 )]
611 if _serde::__private::Option::is_some(&m_fixUpGain) {
612 #[cfg(feature = "ignore_duplicates")]
613 {
614 __A::skip_value(&mut __map)?;
615 continue;
616 }
617 #[cfg(feature = "strict")]
618 return _serde::__private::Err(
619 <__A::Error as _serde::de::Error>::duplicate_field(
620 "fixUpGain",
621 ),
622 );
623 }
624 m_fixUpGain = _serde::__private::Some(
625 match __A::next_value::<f32>(&mut __map) {
626 _serde::__private::Ok(__val) => __val,
627 _serde::__private::Err(__err) => {
628 return _serde::__private::Err(__err);
629 }
630 },
631 );
632 }
633 __Field::m_maxLinearDistance => {
634 #[cfg(
635 any(feature = "strict", feature = "ignore_duplicates")
636 )]
637 if _serde::__private::Option::is_some(
638 &m_maxLinearDistance,
639 ) {
640 #[cfg(feature = "ignore_duplicates")]
641 {
642 __A::skip_value(&mut __map)?;
643 continue;
644 }
645 #[cfg(feature = "strict")]
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::duplicate_field(
648 "maxLinearDistance",
649 ),
650 );
651 }
652 m_maxLinearDistance = _serde::__private::Some(
653 match __A::next_value::<f32>(&mut __map) {
654 _serde::__private::Ok(__val) => __val,
655 _serde::__private::Err(__err) => {
656 return _serde::__private::Err(__err);
657 }
658 },
659 );
660 }
661 __Field::m_maxAngularDistance => {
662 #[cfg(
663 any(feature = "strict", feature = "ignore_duplicates")
664 )]
665 if _serde::__private::Option::is_some(
666 &m_maxAngularDistance,
667 ) {
668 #[cfg(feature = "ignore_duplicates")]
669 {
670 __A::skip_value(&mut __map)?;
671 continue;
672 }
673 #[cfg(feature = "strict")]
674 return _serde::__private::Err(
675 <__A::Error as _serde::de::Error>::duplicate_field(
676 "maxAngularDistance",
677 ),
678 );
679 }
680 m_maxAngularDistance = _serde::__private::Some(
681 match __A::next_value::<f32>(&mut __map) {
682 _serde::__private::Ok(__val) => __val,
683 _serde::__private::Err(__err) => {
684 return _serde::__private::Err(__err);
685 }
686 },
687 );
688 }
689 __Field::m_attachmentType => {
690 #[cfg(
691 any(feature = "strict", feature = "ignore_duplicates")
692 )]
693 if _serde::__private::Option::is_some(&m_attachmentType) {
694 #[cfg(feature = "ignore_duplicates")]
695 {
696 __A::skip_value(&mut __map)?;
697 continue;
698 }
699 #[cfg(feature = "strict")]
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::duplicate_field(
702 "attachmentType",
703 ),
704 );
705 }
706 m_attachmentType = _serde::__private::Some(
707 match __A::next_value::<AttachmentType>(&mut __map) {
708 _serde::__private::Ok(__val) => __val,
709 _serde::__private::Err(__err) => {
710 return _serde::__private::Err(__err);
711 }
712 },
713 );
714 }
715 _ => __A::skip_value(&mut __map)?,
716 }
717 }
718 let m_blendInTime = match m_blendInTime {
719 _serde::__private::Some(__field) => __field,
720 _serde::__private::None => {
721 #[cfg(feature = "strict")]
722 return _serde::__private::Err(
723 <__A::Error as _serde::de::Error>::missing_field(
724 "blendInTime",
725 ),
726 );
727 #[cfg(not(feature = "strict"))] Default::default()
728 }
729 };
730 let m_moveAttacherFraction = match m_moveAttacherFraction {
731 _serde::__private::Some(__field) => __field,
732 _serde::__private::None => {
733 #[cfg(feature = "strict")]
734 return _serde::__private::Err(
735 <__A::Error as _serde::de::Error>::missing_field(
736 "moveAttacherFraction",
737 ),
738 );
739 #[cfg(not(feature = "strict"))] Default::default()
740 }
741 };
742 let m_gain = match m_gain {
743 _serde::__private::Some(__field) => __field,
744 _serde::__private::None => {
745 #[cfg(feature = "strict")]
746 return _serde::__private::Err(
747 <__A::Error as _serde::de::Error>::missing_field("gain"),
748 );
749 #[cfg(not(feature = "strict"))] Default::default()
750 }
751 };
752 let m_extrapolationTimeStep = match m_extrapolationTimeStep {
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 "extrapolationTimeStep",
759 ),
760 );
761 #[cfg(not(feature = "strict"))] Default::default()
762 }
763 };
764 let m_fixUpGain = match m_fixUpGain {
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 "fixUpGain",
771 ),
772 );
773 #[cfg(not(feature = "strict"))] Default::default()
774 }
775 };
776 let m_maxLinearDistance = match m_maxLinearDistance {
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(
782 "maxLinearDistance",
783 ),
784 );
785 #[cfg(not(feature = "strict"))] Default::default()
786 }
787 };
788 let m_maxAngularDistance = match m_maxAngularDistance {
789 _serde::__private::Some(__field) => __field,
790 _serde::__private::None => {
791 #[cfg(feature = "strict")]
792 return _serde::__private::Err(
793 <__A::Error as _serde::de::Error>::missing_field(
794 "maxAngularDistance",
795 ),
796 );
797 #[cfg(not(feature = "strict"))] Default::default()
798 }
799 };
800 let m_attachmentType = match m_attachmentType {
801 _serde::__private::Some(__field) => __field,
802 _serde::__private::None => {
803 #[cfg(feature = "strict")]
804 return _serde::__private::Err(
805 <__A::Error as _serde::de::Error>::missing_field(
806 "attachmentType",
807 ),
808 );
809 #[cfg(not(feature = "strict"))] Default::default()
810 }
811 };
812 let __ptr = None;
813 let parent = hkBaseObject { __ptr };
814 let parent = hkReferencedObject {
815 __ptr,
816 parent,
817 ..Default::default()
818 };
819 let __ptr = __A::class_ptr(&mut __map);
820 _serde::__private::Ok(hkbAttachmentSetup {
821 __ptr,
822 parent,
823 m_blendInTime,
824 m_moveAttacherFraction,
825 m_gain,
826 m_extrapolationTimeStep,
827 m_fixUpGain,
828 m_maxLinearDistance,
829 m_maxAngularDistance,
830 m_attachmentType,
831 })
832 }
833 }
834 const FIELDS: &[&str] = &[
835 "blendInTime",
836 "moveAttacherFraction",
837 "gain",
838 "extrapolationTimeStep",
839 "fixUpGain",
840 "maxLinearDistance",
841 "maxAngularDistance",
842 "attachmentType",
843 ];
844 _serde::Deserializer::deserialize_struct(
845 deserializer,
846 "hkbAttachmentSetup",
847 FIELDS,
848 __hkbAttachmentSetupVisitor {
849 marker: _serde::__private::PhantomData::<hkbAttachmentSetup>,
850 lifetime: _serde::__private::PhantomData,
851 },
852 )
853 }
854 }
855};
856#[allow(non_upper_case_globals, non_snake_case)]
859#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
860#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
861#[derive(
862 Debug,
863 Clone,
864 Default,
865 PartialEq,
866 Eq,
867 PartialOrd,
868 Ord,
869 num_derive::ToPrimitive,
870 num_derive::FromPrimitive,
871)]
872pub enum AttachmentType {
873 #[default]
874 ATTACHMENT_TYPE_KEYFRAME_RIGID_BODY = 0isize,
875 ATTACHMENT_TYPE_BALL_SOCKET_CONSTRAINT = 1isize,
876 ATTACHMENT_TYPE_RAGDOLL_CONSTRAINT = 2isize,
877 ATTACHMENT_TYPE_SET_WORLD_FROM_MODEL = 3isize,
878 ATTACHMENT_TYPE_NONE = 4isize,
879}
880const _: () = {
881 use havok_serde as __serde;
882 impl __serde::Serialize for AttachmentType {
883 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
884 where
885 S: __serde::ser::Serializer,
886 {
887 let mut __serializer = __serializer.serialize_enum_flags()?;
888 match self {
889 Self::ATTACHMENT_TYPE_KEYFRAME_RIGID_BODY => {
890 __serializer
891 .serialize_field("ATTACHMENT_TYPE_KEYFRAME_RIGID_BODY", &0u64)
892 }
893 Self::ATTACHMENT_TYPE_BALL_SOCKET_CONSTRAINT => {
894 __serializer
895 .serialize_field("ATTACHMENT_TYPE_BALL_SOCKET_CONSTRAINT", &1u64)
896 }
897 Self::ATTACHMENT_TYPE_RAGDOLL_CONSTRAINT => {
898 __serializer
899 .serialize_field("ATTACHMENT_TYPE_RAGDOLL_CONSTRAINT", &2u64)
900 }
901 Self::ATTACHMENT_TYPE_SET_WORLD_FROM_MODEL => {
902 __serializer
903 .serialize_field("ATTACHMENT_TYPE_SET_WORLD_FROM_MODEL", &3u64)
904 }
905 Self::ATTACHMENT_TYPE_NONE => {
906 __serializer.serialize_field("ATTACHMENT_TYPE_NONE", &4u64)
907 }
908 }?;
909 use num_traits::ToPrimitive as _;
910 let num = self
911 .to_i8()
912 .ok_or(S::Error::custom("Failed enum AttachmentType to_i8"))?;
913 __serializer.serialize_bits(&num)?;
914 __serializer.end()
915 }
916 }
917};
918#[doc(hidden)]
919#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
920const _: () = {
921 #[allow(unused_extern_crates, clippy::useless_attribute)]
922 extern crate havok_serde as _serde;
923 #[automatically_derived]
924 impl<'de> _serde::Deserialize<'de> for AttachmentType {
925 fn deserialize<__D>(
926 __deserializer: __D,
927 ) -> _serde::__private::Result<Self, __D::Error>
928 where
929 __D: _serde::Deserializer<'de>,
930 {
931 #[allow(non_camel_case_types)]
932 #[doc(hidden)]
933 enum __Field {
934 __field0,
935 __field1,
936 __field2,
937 __field3,
938 __field4,
939 }
940 #[doc(hidden)]
941 struct __FieldVisitor;
942 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
943 type Value = __Field;
944 fn expecting(
945 &self,
946 __formatter: &mut _serde::__private::Formatter,
947 ) -> _serde::__private::fmt::Result {
948 _serde::__private::Formatter::write_str(
949 __formatter,
950 "variant identifier",
951 )
952 }
953 fn visit_int8<__E>(
954 self,
955 __value: i8,
956 ) -> _serde::__private::Result<Self::Value, __E>
957 where
958 __E: _serde::de::Error,
959 {
960 match __value {
961 0i8 => _serde::__private::Ok(__Field::__field0),
962 1i8 => _serde::__private::Ok(__Field::__field1),
963 2i8 => _serde::__private::Ok(__Field::__field2),
964 3i8 => _serde::__private::Ok(__Field::__field3),
965 4i8 => _serde::__private::Ok(__Field::__field4),
966 _ => {
967 _serde::__private::Err(
968 _serde::de::Error::invalid_value(
969 _serde::de::Unexpected::Int8(__value),
970 &"value(i8) of variant is one of 0, 1, 2, 3, 4",
971 ),
972 )
973 }
974 }
975 }
976 fn visit_stringptr<__E>(
977 self,
978 __value: StringPtr<'de>,
979 ) -> _serde::__private::Result<Self::Value, __E>
980 where
981 __E: _serde::de::Error,
982 {
983 if let Some(__value) = __value.into_inner() {
984 match __value.as_ref() {
985 v if v == "0"
986 || v
987 .eq_ignore_ascii_case(
988 "ATTACHMENT_TYPE_KEYFRAME_RIGID_BODY",
989 ) => _serde::__private::Ok(__Field::__field0),
990 v if v == "1"
991 || v
992 .eq_ignore_ascii_case(
993 "ATTACHMENT_TYPE_BALL_SOCKET_CONSTRAINT",
994 ) => _serde::__private::Ok(__Field::__field1),
995 v if v == "2"
996 || v
997 .eq_ignore_ascii_case(
998 "ATTACHMENT_TYPE_RAGDOLL_CONSTRAINT",
999 ) => _serde::__private::Ok(__Field::__field2),
1000 v if v == "3"
1001 || v
1002 .eq_ignore_ascii_case(
1003 "ATTACHMENT_TYPE_SET_WORLD_FROM_MODEL",
1004 ) => _serde::__private::Ok(__Field::__field3),
1005 v if v == "4"
1006 || v.eq_ignore_ascii_case("ATTACHMENT_TYPE_NONE") => {
1007 _serde::__private::Ok(__Field::__field4)
1008 }
1009 _ => {
1010 _serde::__private::Err(
1011 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1012 )
1013 }
1014 }
1015 } else {
1016 _serde::__private::Err(
1017 _serde::de::Error::unknown_variant("None", VARIANTS),
1018 )
1019 }
1020 }
1021 }
1022 impl<'de> _serde::Deserialize<'de> for __Field {
1023 #[inline]
1024 fn deserialize<__D>(
1025 __deserializer: __D,
1026 ) -> _serde::__private::Result<Self, __D::Error>
1027 where
1028 __D: _serde::Deserializer<'de>,
1029 {
1030 _serde::Deserializer::deserialize_identifier(
1031 __deserializer,
1032 _serde::de::ReadEnumSize::Int8,
1033 __FieldVisitor,
1034 )
1035 }
1036 }
1037 #[doc(hidden)]
1038 struct __Visitor<'de> {
1039 marker: _serde::__private::PhantomData<AttachmentType>,
1040 lifetime: _serde::__private::PhantomData<&'de ()>,
1041 }
1042 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1043 type Value = AttachmentType;
1044 fn expecting(
1045 &self,
1046 __formatter: &mut _serde::__private::Formatter,
1047 ) -> _serde::__private::fmt::Result {
1048 _serde::__private::Formatter::write_str(
1049 __formatter,
1050 "enum AttachmentType",
1051 )
1052 }
1053 fn visit_enum<__A>(
1054 self,
1055 __data: __A,
1056 ) -> _serde::__private::Result<Self::Value, __A::Error>
1057 where
1058 __A: _serde::de::EnumAccess<'de>,
1059 {
1060 match _serde::de::EnumAccess::variant(__data)? {
1061 (__Field::__field0, __variant) => {
1062 _serde::de::VariantAccess::unit_variant(__variant)?;
1063 _serde::__private::Ok(
1064 AttachmentType::ATTACHMENT_TYPE_KEYFRAME_RIGID_BODY,
1065 )
1066 }
1067 (__Field::__field1, __variant) => {
1068 _serde::de::VariantAccess::unit_variant(__variant)?;
1069 _serde::__private::Ok(
1070 AttachmentType::ATTACHMENT_TYPE_BALL_SOCKET_CONSTRAINT,
1071 )
1072 }
1073 (__Field::__field2, __variant) => {
1074 _serde::de::VariantAccess::unit_variant(__variant)?;
1075 _serde::__private::Ok(
1076 AttachmentType::ATTACHMENT_TYPE_RAGDOLL_CONSTRAINT,
1077 )
1078 }
1079 (__Field::__field3, __variant) => {
1080 _serde::de::VariantAccess::unit_variant(__variant)?;
1081 _serde::__private::Ok(
1082 AttachmentType::ATTACHMENT_TYPE_SET_WORLD_FROM_MODEL,
1083 )
1084 }
1085 (__Field::__field4, __variant) => {
1086 _serde::de::VariantAccess::unit_variant(__variant)?;
1087 _serde::__private::Ok(AttachmentType::ATTACHMENT_TYPE_NONE)
1088 }
1089 }
1090 }
1091 }
1092 #[doc(hidden)]
1093 const VARIANTS: &'static [&'static str] = &[
1094 "ATTACHMENT_TYPE_KEYFRAME_RIGID_BODY",
1095 "ATTACHMENT_TYPE_BALL_SOCKET_CONSTRAINT",
1096 "ATTACHMENT_TYPE_RAGDOLL_CONSTRAINT",
1097 "ATTACHMENT_TYPE_SET_WORLD_FROM_MODEL",
1098 "ATTACHMENT_TYPE_NONE",
1099 ];
1100 _serde::Deserializer::deserialize_enum(
1101 __deserializer,
1102 "AttachmentType",
1103 VARIANTS,
1104 __Visitor {
1105 marker: _serde::__private::PhantomData::<AttachmentType>,
1106 lifetime: _serde::__private::PhantomData,
1107 },
1108 )
1109 }
1110 }
1111};