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