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