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