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 hkaSplineCompressedAnimation<'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 = "numFrames"))]
36 #[cfg_attr(feature = "serde", serde(rename = "numFrames"))]
37 pub m_numFrames: i32,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "numBlocks"))]
43 #[cfg_attr(feature = "serde", serde(rename = "numBlocks"))]
44 pub m_numBlocks: i32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "maxFramesPerBlock"))]
50 #[cfg_attr(feature = "serde", serde(rename = "maxFramesPerBlock"))]
51 pub m_maxFramesPerBlock: i32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "maskAndQuantizationSize"))]
57 #[cfg_attr(feature = "serde", serde(rename = "maskAndQuantizationSize"))]
58 pub m_maskAndQuantizationSize: i32,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "blockDuration"))]
64 #[cfg_attr(feature = "serde", serde(rename = "blockDuration"))]
65 pub m_blockDuration: f32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "blockInverseDuration"))]
71 #[cfg_attr(feature = "serde", serde(rename = "blockInverseDuration"))]
72 pub m_blockInverseDuration: f32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "frameDuration"))]
78 #[cfg_attr(feature = "serde", serde(rename = "frameDuration"))]
79 pub m_frameDuration: f32,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "blockOffsets"))]
85 #[cfg_attr(feature = "serde", serde(rename = "blockOffsets"))]
86 pub m_blockOffsets: Vec<u32>,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "floatBlockOffsets"))]
92 #[cfg_attr(feature = "serde", serde(rename = "floatBlockOffsets"))]
93 pub m_floatBlockOffsets: Vec<u32>,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "transformOffsets"))]
99 #[cfg_attr(feature = "serde", serde(rename = "transformOffsets"))]
100 pub m_transformOffsets: Vec<u32>,
101 #[cfg_attr(feature = "json_schema", schemars(rename = "floatOffsets"))]
106 #[cfg_attr(feature = "serde", serde(rename = "floatOffsets"))]
107 pub m_floatOffsets: Vec<u32>,
108 #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
113 #[cfg_attr(feature = "serde", serde(rename = "data"))]
114 pub m_data: Vec<u8>,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "endian"))]
120 #[cfg_attr(feature = "serde", serde(rename = "endian"))]
121 pub m_endian: i32,
122}
123const _: () = {
124 use havok_serde as _serde;
125 impl<'a> _serde::HavokClass for hkaSplineCompressedAnimation<'a> {
126 #[inline]
127 fn name(&self) -> &'static str {
128 "hkaSplineCompressedAnimation"
129 }
130 #[inline]
131 fn signature(&self) -> _serde::__private::Signature {
132 _serde::__private::Signature::new(0x792ee0bb)
133 }
134 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
135 fn deps_indexes(&self) -> Vec<usize> {
136 let mut v = Vec::new();
137 v.push(self.parent.m_extractedMotion.get());
138 v.extend(
139 self
140 .parent
141 .m_annotationTracks
142 .iter()
143 .flat_map(|class| class.deps_indexes())
144 .collect::<Vec<usize>>(),
145 );
146 v
147 }
148 }
149 impl<'a> _serde::Serialize for hkaSplineCompressedAnimation<'a> {
150 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
151 where
152 S: _serde::ser::Serializer,
153 {
154 let class_meta = self
155 .__ptr
156 .map(|name| (name, _serde::__private::Signature::new(0x792ee0bb)));
157 let mut serializer = __serializer
158 .serialize_struct(
159 "hkaSplineCompressedAnimation",
160 class_meta,
161 (132u64, 176u64),
162 )?;
163 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
164 serializer
165 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
166 serializer
167 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
168 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
169 serializer.serialize_field("type", &self.parent.m_type)?;
170 serializer.serialize_field("duration", &self.parent.m_duration)?;
171 serializer
172 .serialize_field(
173 "numberOfTransformTracks",
174 &self.parent.m_numberOfTransformTracks,
175 )?;
176 serializer
177 .serialize_field(
178 "numberOfFloatTracks",
179 &self.parent.m_numberOfFloatTracks,
180 )?;
181 serializer
182 .serialize_field("extractedMotion", &self.parent.m_extractedMotion)?;
183 serializer
184 .serialize_array_field(
185 "annotationTracks",
186 &self.parent.m_annotationTracks,
187 TypeSize::Struct {
188 size_x86: 16u64,
189 size_x86_64: 24u64,
190 },
191 )?;
192 serializer.serialize_field("numFrames", &self.m_numFrames)?;
193 serializer.serialize_field("numBlocks", &self.m_numBlocks)?;
194 serializer.serialize_field("maxFramesPerBlock", &self.m_maxFramesPerBlock)?;
195 serializer
196 .serialize_field(
197 "maskAndQuantizationSize",
198 &self.m_maskAndQuantizationSize,
199 )?;
200 serializer.serialize_field("blockDuration", &self.m_blockDuration)?;
201 serializer
202 .serialize_field("blockInverseDuration", &self.m_blockInverseDuration)?;
203 serializer.serialize_field("frameDuration", &self.m_frameDuration)?;
204 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
205 serializer
206 .serialize_array_field(
207 "blockOffsets",
208 &self.m_blockOffsets,
209 TypeSize::NonPtr,
210 )?;
211 serializer
212 .serialize_array_field(
213 "floatBlockOffsets",
214 &self.m_floatBlockOffsets,
215 TypeSize::NonPtr,
216 )?;
217 serializer
218 .serialize_array_field(
219 "transformOffsets",
220 &self.m_transformOffsets,
221 TypeSize::NonPtr,
222 )?;
223 serializer
224 .serialize_array_field(
225 "floatOffsets",
226 &self.m_floatOffsets,
227 TypeSize::NonPtr,
228 )?;
229 serializer.serialize_array_field("data", &self.m_data, TypeSize::NonPtr)?;
230 serializer.serialize_field("endian", &self.m_endian)?;
231 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
232 serializer.end()
233 }
234 }
235};
236#[doc(hidden)]
237#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
238const _: () = {
239 use havok_serde as _serde;
240 #[automatically_derived]
241 impl<'de> _serde::Deserialize<'de> for hkaSplineCompressedAnimation<'de> {
242 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
243 where
244 __D: _serde::Deserializer<'de>,
245 {
246 #[allow(non_camel_case_types)]
247 enum __Field {
248 m_type,
249 m_duration,
250 m_numberOfTransformTracks,
251 m_numberOfFloatTracks,
252 m_extractedMotion,
253 m_annotationTracks,
254 m_numFrames,
255 m_numBlocks,
256 m_maxFramesPerBlock,
257 m_maskAndQuantizationSize,
258 m_blockDuration,
259 m_blockInverseDuration,
260 m_frameDuration,
261 m_blockOffsets,
262 m_floatBlockOffsets,
263 m_transformOffsets,
264 m_floatOffsets,
265 m_data,
266 m_endian,
267 __ignore,
268 }
269 struct __FieldVisitor;
270 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
271 type Value = __Field;
272 fn expecting(
273 &self,
274 __formatter: &mut core::fmt::Formatter,
275 ) -> core::fmt::Result {
276 core::fmt::Formatter::write_str(__formatter, "field identifier")
277 }
278 #[allow(clippy::match_single_binding)]
280 #[allow(clippy::reversed_empty_ranges)]
281 #[allow(clippy::single_match)]
282 fn visit_key<__E>(
283 self,
284 __value: &str,
285 ) -> core::result::Result<Self::Value, __E>
286 where
287 __E: _serde::de::Error,
288 {
289 match __value {
290 "type" => Ok(__Field::m_type),
291 "duration" => Ok(__Field::m_duration),
292 "numberOfTransformTracks" => {
293 Ok(__Field::m_numberOfTransformTracks)
294 }
295 "numberOfFloatTracks" => Ok(__Field::m_numberOfFloatTracks),
296 "extractedMotion" => Ok(__Field::m_extractedMotion),
297 "annotationTracks" => Ok(__Field::m_annotationTracks),
298 "numFrames" => Ok(__Field::m_numFrames),
299 "numBlocks" => Ok(__Field::m_numBlocks),
300 "maxFramesPerBlock" => Ok(__Field::m_maxFramesPerBlock),
301 "maskAndQuantizationSize" => {
302 Ok(__Field::m_maskAndQuantizationSize)
303 }
304 "blockDuration" => Ok(__Field::m_blockDuration),
305 "blockInverseDuration" => Ok(__Field::m_blockInverseDuration),
306 "frameDuration" => Ok(__Field::m_frameDuration),
307 "blockOffsets" => Ok(__Field::m_blockOffsets),
308 "floatBlockOffsets" => Ok(__Field::m_floatBlockOffsets),
309 "transformOffsets" => Ok(__Field::m_transformOffsets),
310 "floatOffsets" => Ok(__Field::m_floatOffsets),
311 "data" => Ok(__Field::m_data),
312 "endian" => Ok(__Field::m_endian),
313 _ => Ok(__Field::__ignore),
314 }
315 }
316 }
317 impl<'de> _serde::Deserialize<'de> for __Field {
318 #[inline]
319 fn deserialize<__D>(
320 __deserializer: __D,
321 ) -> core::result::Result<Self, __D::Error>
322 where
323 __D: _serde::Deserializer<'de>,
324 {
325 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
326 }
327 }
328 struct __hkaSplineCompressedAnimationVisitor<'de> {
329 marker: _serde::__private::PhantomData<
330 hkaSplineCompressedAnimation<'de>,
331 >,
332 lifetime: _serde::__private::PhantomData<&'de ()>,
333 }
334 #[allow(clippy::match_single_binding)]
335 #[allow(clippy::reversed_empty_ranges)]
336 #[allow(clippy::single_match)]
337 impl<'de> _serde::de::Visitor<'de>
338 for __hkaSplineCompressedAnimationVisitor<'de> {
339 type Value = hkaSplineCompressedAnimation<'de>;
340 fn expecting(
341 &self,
342 __formatter: &mut core::fmt::Formatter,
343 ) -> core::fmt::Result {
344 core::fmt::Formatter::write_str(
345 __formatter,
346 "struct hkaSplineCompressedAnimation",
347 )
348 }
349 fn visit_struct_for_bytes<__A>(
350 self,
351 mut __map: __A,
352 ) -> _serde::__private::Result<Self::Value, __A::Error>
353 where
354 __A: _serde::de::MapAccess<'de>,
355 {
356 let __ptr = __A::class_ptr(&mut __map);
357 let parent = __A::parent_value(&mut __map)?;
358 let mut m_numFrames: _serde::__private::Option<i32> = _serde::__private::None;
359 let mut m_numBlocks: _serde::__private::Option<i32> = _serde::__private::None;
360 let mut m_maxFramesPerBlock: _serde::__private::Option<i32> = _serde::__private::None;
361 let mut m_maskAndQuantizationSize: _serde::__private::Option<i32> = _serde::__private::None;
362 let mut m_blockDuration: _serde::__private::Option<f32> = _serde::__private::None;
363 let mut m_blockInverseDuration: _serde::__private::Option<f32> = _serde::__private::None;
364 let mut m_frameDuration: _serde::__private::Option<f32> = _serde::__private::None;
365 let mut m_blockOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
366 let mut m_floatBlockOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
367 let mut m_transformOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
368 let mut m_floatOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
369 let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
370 let mut m_endian: _serde::__private::Option<i32> = _serde::__private::None;
371 for i in 0..13usize {
372 match i {
373 0usize => {
374 if _serde::__private::Option::is_some(&m_numFrames) {
375 return _serde::__private::Err(
376 <__A::Error as _serde::de::Error>::duplicate_field(
377 "numFrames",
378 ),
379 );
380 }
381 m_numFrames = _serde::__private::Some(
382 match __A::next_value::<i32>(&mut __map) {
383 _serde::__private::Ok(__val) => __val,
384 _serde::__private::Err(__err) => {
385 return _serde::__private::Err(__err);
386 }
387 },
388 );
389 }
390 1usize => {
391 if _serde::__private::Option::is_some(&m_numBlocks) {
392 return _serde::__private::Err(
393 <__A::Error as _serde::de::Error>::duplicate_field(
394 "numBlocks",
395 ),
396 );
397 }
398 m_numBlocks = _serde::__private::Some(
399 match __A::next_value::<i32>(&mut __map) {
400 _serde::__private::Ok(__val) => __val,
401 _serde::__private::Err(__err) => {
402 return _serde::__private::Err(__err);
403 }
404 },
405 );
406 }
407 2usize => {
408 if _serde::__private::Option::is_some(
409 &m_maxFramesPerBlock,
410 ) {
411 return _serde::__private::Err(
412 <__A::Error as _serde::de::Error>::duplicate_field(
413 "maxFramesPerBlock",
414 ),
415 );
416 }
417 m_maxFramesPerBlock = _serde::__private::Some(
418 match __A::next_value::<i32>(&mut __map) {
419 _serde::__private::Ok(__val) => __val,
420 _serde::__private::Err(__err) => {
421 return _serde::__private::Err(__err);
422 }
423 },
424 );
425 }
426 3usize => {
427 if _serde::__private::Option::is_some(
428 &m_maskAndQuantizationSize,
429 ) {
430 return _serde::__private::Err(
431 <__A::Error as _serde::de::Error>::duplicate_field(
432 "maskAndQuantizationSize",
433 ),
434 );
435 }
436 m_maskAndQuantizationSize = _serde::__private::Some(
437 match __A::next_value::<i32>(&mut __map) {
438 _serde::__private::Ok(__val) => __val,
439 _serde::__private::Err(__err) => {
440 return _serde::__private::Err(__err);
441 }
442 },
443 );
444 }
445 4usize => {
446 if _serde::__private::Option::is_some(&m_blockDuration) {
447 return _serde::__private::Err(
448 <__A::Error as _serde::de::Error>::duplicate_field(
449 "blockDuration",
450 ),
451 );
452 }
453 m_blockDuration = _serde::__private::Some(
454 match __A::next_value::<f32>(&mut __map) {
455 _serde::__private::Ok(__val) => __val,
456 _serde::__private::Err(__err) => {
457 return _serde::__private::Err(__err);
458 }
459 },
460 );
461 }
462 5usize => {
463 if _serde::__private::Option::is_some(
464 &m_blockInverseDuration,
465 ) {
466 return _serde::__private::Err(
467 <__A::Error as _serde::de::Error>::duplicate_field(
468 "blockInverseDuration",
469 ),
470 );
471 }
472 m_blockInverseDuration = _serde::__private::Some(
473 match __A::next_value::<f32>(&mut __map) {
474 _serde::__private::Ok(__val) => __val,
475 _serde::__private::Err(__err) => {
476 return _serde::__private::Err(__err);
477 }
478 },
479 );
480 }
481 6usize => {
482 if _serde::__private::Option::is_some(&m_frameDuration) {
483 return _serde::__private::Err(
484 <__A::Error as _serde::de::Error>::duplicate_field(
485 "frameDuration",
486 ),
487 );
488 }
489 m_frameDuration = _serde::__private::Some(
490 match __A::next_value::<f32>(&mut __map) {
491 _serde::__private::Ok(__val) => __val,
492 _serde::__private::Err(__err) => {
493 return _serde::__private::Err(__err);
494 }
495 },
496 );
497 }
498 7usize => {
499 if _serde::__private::Option::is_some(&m_blockOffsets) {
500 return _serde::__private::Err(
501 <__A::Error as _serde::de::Error>::duplicate_field(
502 "blockOffsets",
503 ),
504 );
505 }
506 __A::pad(&mut __map, 0usize, 4usize)?;
507 m_blockOffsets = _serde::__private::Some(
508 match __A::next_value::<Vec<u32>>(&mut __map) {
509 _serde::__private::Ok(__val) => __val,
510 _serde::__private::Err(__err) => {
511 return _serde::__private::Err(__err);
512 }
513 },
514 );
515 }
516 8usize => {
517 if _serde::__private::Option::is_some(
518 &m_floatBlockOffsets,
519 ) {
520 return _serde::__private::Err(
521 <__A::Error as _serde::de::Error>::duplicate_field(
522 "floatBlockOffsets",
523 ),
524 );
525 }
526 m_floatBlockOffsets = _serde::__private::Some(
527 match __A::next_value::<Vec<u32>>(&mut __map) {
528 _serde::__private::Ok(__val) => __val,
529 _serde::__private::Err(__err) => {
530 return _serde::__private::Err(__err);
531 }
532 },
533 );
534 }
535 9usize => {
536 if _serde::__private::Option::is_some(&m_transformOffsets) {
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::duplicate_field(
539 "transformOffsets",
540 ),
541 );
542 }
543 m_transformOffsets = _serde::__private::Some(
544 match __A::next_value::<Vec<u32>>(&mut __map) {
545 _serde::__private::Ok(__val) => __val,
546 _serde::__private::Err(__err) => {
547 return _serde::__private::Err(__err);
548 }
549 },
550 );
551 }
552 10usize => {
553 if _serde::__private::Option::is_some(&m_floatOffsets) {
554 return _serde::__private::Err(
555 <__A::Error as _serde::de::Error>::duplicate_field(
556 "floatOffsets",
557 ),
558 );
559 }
560 m_floatOffsets = _serde::__private::Some(
561 match __A::next_value::<Vec<u32>>(&mut __map) {
562 _serde::__private::Ok(__val) => __val,
563 _serde::__private::Err(__err) => {
564 return _serde::__private::Err(__err);
565 }
566 },
567 );
568 }
569 11usize => {
570 if _serde::__private::Option::is_some(&m_data) {
571 return _serde::__private::Err(
572 <__A::Error as _serde::de::Error>::duplicate_field("data"),
573 );
574 }
575 m_data = _serde::__private::Some(
576 match __A::next_value::<Vec<u8>>(&mut __map) {
577 _serde::__private::Ok(__val) => __val,
578 _serde::__private::Err(__err) => {
579 return _serde::__private::Err(__err);
580 }
581 },
582 );
583 }
584 12usize => {
585 if _serde::__private::Option::is_some(&m_endian) {
586 return _serde::__private::Err(
587 <__A::Error as _serde::de::Error>::duplicate_field("endian"),
588 );
589 }
590 m_endian = _serde::__private::Some(
591 match __A::next_value::<i32>(&mut __map) {
592 _serde::__private::Ok(__val) => __val,
593 _serde::__private::Err(__err) => {
594 return _serde::__private::Err(__err);
595 }
596 },
597 );
598 }
599 _ => {}
600 }
601 }
602 __A::pad(&mut __map, 0usize, 4usize)?;
603 let m_numFrames = match m_numFrames {
604 _serde::__private::Some(__field) => __field,
605 _serde::__private::None => {
606 return _serde::__private::Err(
607 <__A::Error as _serde::de::Error>::missing_field(
608 "numFrames",
609 ),
610 );
611 }
612 };
613 let m_numBlocks = match m_numBlocks {
614 _serde::__private::Some(__field) => __field,
615 _serde::__private::None => {
616 return _serde::__private::Err(
617 <__A::Error as _serde::de::Error>::missing_field(
618 "numBlocks",
619 ),
620 );
621 }
622 };
623 let m_maxFramesPerBlock = match m_maxFramesPerBlock {
624 _serde::__private::Some(__field) => __field,
625 _serde::__private::None => {
626 return _serde::__private::Err(
627 <__A::Error as _serde::de::Error>::missing_field(
628 "maxFramesPerBlock",
629 ),
630 );
631 }
632 };
633 let m_maskAndQuantizationSize = match m_maskAndQuantizationSize {
634 _serde::__private::Some(__field) => __field,
635 _serde::__private::None => {
636 return _serde::__private::Err(
637 <__A::Error as _serde::de::Error>::missing_field(
638 "maskAndQuantizationSize",
639 ),
640 );
641 }
642 };
643 let m_blockDuration = match m_blockDuration {
644 _serde::__private::Some(__field) => __field,
645 _serde::__private::None => {
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::missing_field(
648 "blockDuration",
649 ),
650 );
651 }
652 };
653 let m_blockInverseDuration = match m_blockInverseDuration {
654 _serde::__private::Some(__field) => __field,
655 _serde::__private::None => {
656 return _serde::__private::Err(
657 <__A::Error as _serde::de::Error>::missing_field(
658 "blockInverseDuration",
659 ),
660 );
661 }
662 };
663 let m_frameDuration = match m_frameDuration {
664 _serde::__private::Some(__field) => __field,
665 _serde::__private::None => {
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::missing_field(
668 "frameDuration",
669 ),
670 );
671 }
672 };
673 let m_blockOffsets = match m_blockOffsets {
674 _serde::__private::Some(__field) => __field,
675 _serde::__private::None => {
676 return _serde::__private::Err(
677 <__A::Error as _serde::de::Error>::missing_field(
678 "blockOffsets",
679 ),
680 );
681 }
682 };
683 let m_floatBlockOffsets = match m_floatBlockOffsets {
684 _serde::__private::Some(__field) => __field,
685 _serde::__private::None => {
686 return _serde::__private::Err(
687 <__A::Error as _serde::de::Error>::missing_field(
688 "floatBlockOffsets",
689 ),
690 );
691 }
692 };
693 let m_transformOffsets = match m_transformOffsets {
694 _serde::__private::Some(__field) => __field,
695 _serde::__private::None => {
696 return _serde::__private::Err(
697 <__A::Error as _serde::de::Error>::missing_field(
698 "transformOffsets",
699 ),
700 );
701 }
702 };
703 let m_floatOffsets = match m_floatOffsets {
704 _serde::__private::Some(__field) => __field,
705 _serde::__private::None => {
706 return _serde::__private::Err(
707 <__A::Error as _serde::de::Error>::missing_field(
708 "floatOffsets",
709 ),
710 );
711 }
712 };
713 let m_data = match m_data {
714 _serde::__private::Some(__field) => __field,
715 _serde::__private::None => {
716 return _serde::__private::Err(
717 <__A::Error as _serde::de::Error>::missing_field("data"),
718 );
719 }
720 };
721 let m_endian = match m_endian {
722 _serde::__private::Some(__field) => __field,
723 _serde::__private::None => {
724 return _serde::__private::Err(
725 <__A::Error as _serde::de::Error>::missing_field("endian"),
726 );
727 }
728 };
729 _serde::__private::Ok(hkaSplineCompressedAnimation {
730 __ptr,
731 parent,
732 m_numFrames,
733 m_numBlocks,
734 m_maxFramesPerBlock,
735 m_maskAndQuantizationSize,
736 m_blockDuration,
737 m_blockInverseDuration,
738 m_frameDuration,
739 m_blockOffsets,
740 m_floatBlockOffsets,
741 m_transformOffsets,
742 m_floatOffsets,
743 m_data,
744 m_endian,
745 })
746 }
747 #[allow(clippy::manual_unwrap_or_default)]
748 fn visit_struct<__A>(
749 self,
750 mut __map: __A,
751 ) -> _serde::__private::Result<Self::Value, __A::Error>
752 where
753 __A: _serde::de::MapAccess<'de>,
754 {
755 let mut m_type: _serde::__private::Option<AnimationType> = _serde::__private::None;
756 let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
757 let mut m_numberOfTransformTracks: _serde::__private::Option<i32> = _serde::__private::None;
758 let mut m_numberOfFloatTracks: _serde::__private::Option<i32> = _serde::__private::None;
759 let mut m_extractedMotion: _serde::__private::Option<Pointer> = _serde::__private::None;
760 let mut m_annotationTracks: _serde::__private::Option<
761 Vec<hkaAnnotationTrack<'de>>,
762 > = _serde::__private::None;
763 let mut m_numFrames: _serde::__private::Option<i32> = _serde::__private::None;
764 let mut m_numBlocks: _serde::__private::Option<i32> = _serde::__private::None;
765 let mut m_maxFramesPerBlock: _serde::__private::Option<i32> = _serde::__private::None;
766 let mut m_maskAndQuantizationSize: _serde::__private::Option<i32> = _serde::__private::None;
767 let mut m_blockDuration: _serde::__private::Option<f32> = _serde::__private::None;
768 let mut m_blockInverseDuration: _serde::__private::Option<f32> = _serde::__private::None;
769 let mut m_frameDuration: _serde::__private::Option<f32> = _serde::__private::None;
770 let mut m_blockOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
771 let mut m_floatBlockOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
772 let mut m_transformOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
773 let mut m_floatOffsets: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
774 let mut m_data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
775 let mut m_endian: _serde::__private::Option<i32> = _serde::__private::None;
776 while let _serde::__private::Some(__key) = {
777 __A::next_key::<__Field>(&mut __map)?
778 } {
779 match __key {
780 __Field::m_type => {
781 #[cfg(
782 any(feature = "strict", feature = "ignore_duplicates")
783 )]
784 if _serde::__private::Option::is_some(&m_type) {
785 #[cfg(feature = "ignore_duplicates")]
786 {
787 __A::skip_value(&mut __map)?;
788 continue;
789 }
790 #[cfg(feature = "strict")]
791 return _serde::__private::Err(
792 <__A::Error as _serde::de::Error>::duplicate_field("type"),
793 );
794 }
795 m_type = _serde::__private::Some(
796 match __A::next_value::<AnimationType>(&mut __map) {
797 _serde::__private::Ok(__val) => __val,
798 _serde::__private::Err(__err) => {
799 return _serde::__private::Err(__err);
800 }
801 },
802 );
803 }
804 __Field::m_duration => {
805 #[cfg(
806 any(feature = "strict", feature = "ignore_duplicates")
807 )]
808 if _serde::__private::Option::is_some(&m_duration) {
809 #[cfg(feature = "ignore_duplicates")]
810 {
811 __A::skip_value(&mut __map)?;
812 continue;
813 }
814 #[cfg(feature = "strict")]
815 return _serde::__private::Err(
816 <__A::Error as _serde::de::Error>::duplicate_field(
817 "duration",
818 ),
819 );
820 }
821 m_duration = _serde::__private::Some(
822 match __A::next_value::<f32>(&mut __map) {
823 _serde::__private::Ok(__val) => __val,
824 _serde::__private::Err(__err) => {
825 return _serde::__private::Err(__err);
826 }
827 },
828 );
829 }
830 __Field::m_numberOfTransformTracks => {
831 #[cfg(
832 any(feature = "strict", feature = "ignore_duplicates")
833 )]
834 if _serde::__private::Option::is_some(
835 &m_numberOfTransformTracks,
836 ) {
837 #[cfg(feature = "ignore_duplicates")]
838 {
839 __A::skip_value(&mut __map)?;
840 continue;
841 }
842 #[cfg(feature = "strict")]
843 return _serde::__private::Err(
844 <__A::Error as _serde::de::Error>::duplicate_field(
845 "numberOfTransformTracks",
846 ),
847 );
848 }
849 m_numberOfTransformTracks = _serde::__private::Some(
850 match __A::next_value::<i32>(&mut __map) {
851 _serde::__private::Ok(__val) => __val,
852 _serde::__private::Err(__err) => {
853 return _serde::__private::Err(__err);
854 }
855 },
856 );
857 }
858 __Field::m_numberOfFloatTracks => {
859 #[cfg(
860 any(feature = "strict", feature = "ignore_duplicates")
861 )]
862 if _serde::__private::Option::is_some(
863 &m_numberOfFloatTracks,
864 ) {
865 #[cfg(feature = "ignore_duplicates")]
866 {
867 __A::skip_value(&mut __map)?;
868 continue;
869 }
870 #[cfg(feature = "strict")]
871 return _serde::__private::Err(
872 <__A::Error as _serde::de::Error>::duplicate_field(
873 "numberOfFloatTracks",
874 ),
875 );
876 }
877 m_numberOfFloatTracks = _serde::__private::Some(
878 match __A::next_value::<i32>(&mut __map) {
879 _serde::__private::Ok(__val) => __val,
880 _serde::__private::Err(__err) => {
881 return _serde::__private::Err(__err);
882 }
883 },
884 );
885 }
886 __Field::m_extractedMotion => {
887 #[cfg(
888 any(feature = "strict", feature = "ignore_duplicates")
889 )]
890 if _serde::__private::Option::is_some(&m_extractedMotion) {
891 #[cfg(feature = "ignore_duplicates")]
892 {
893 __A::skip_value(&mut __map)?;
894 continue;
895 }
896 #[cfg(feature = "strict")]
897 return _serde::__private::Err(
898 <__A::Error as _serde::de::Error>::duplicate_field(
899 "extractedMotion",
900 ),
901 );
902 }
903 m_extractedMotion = _serde::__private::Some(
904 match __A::next_value::<Pointer>(&mut __map) {
905 _serde::__private::Ok(__val) => __val,
906 _serde::__private::Err(__err) => {
907 return _serde::__private::Err(__err);
908 }
909 },
910 );
911 }
912 __Field::m_annotationTracks => {
913 #[cfg(
914 any(feature = "strict", feature = "ignore_duplicates")
915 )]
916 if _serde::__private::Option::is_some(&m_annotationTracks) {
917 #[cfg(feature = "ignore_duplicates")]
918 {
919 __A::skip_value(&mut __map)?;
920 continue;
921 }
922 #[cfg(feature = "strict")]
923 return _serde::__private::Err(
924 <__A::Error as _serde::de::Error>::duplicate_field(
925 "annotationTracks",
926 ),
927 );
928 }
929 m_annotationTracks = _serde::__private::Some(
930 match __A::next_value::<
931 Vec<hkaAnnotationTrack<'de>>,
932 >(&mut __map) {
933 _serde::__private::Ok(__val) => __val,
934 _serde::__private::Err(__err) => {
935 return _serde::__private::Err(__err);
936 }
937 },
938 );
939 }
940 __Field::m_numFrames => {
941 #[cfg(
942 any(feature = "strict", feature = "ignore_duplicates")
943 )]
944 if _serde::__private::Option::is_some(&m_numFrames) {
945 #[cfg(feature = "ignore_duplicates")]
946 {
947 __A::skip_value(&mut __map)?;
948 continue;
949 }
950 #[cfg(feature = "strict")]
951 return _serde::__private::Err(
952 <__A::Error as _serde::de::Error>::duplicate_field(
953 "numFrames",
954 ),
955 );
956 }
957 m_numFrames = _serde::__private::Some(
958 match __A::next_value::<i32>(&mut __map) {
959 _serde::__private::Ok(__val) => __val,
960 _serde::__private::Err(__err) => {
961 return _serde::__private::Err(__err);
962 }
963 },
964 );
965 }
966 __Field::m_numBlocks => {
967 #[cfg(
968 any(feature = "strict", feature = "ignore_duplicates")
969 )]
970 if _serde::__private::Option::is_some(&m_numBlocks) {
971 #[cfg(feature = "ignore_duplicates")]
972 {
973 __A::skip_value(&mut __map)?;
974 continue;
975 }
976 #[cfg(feature = "strict")]
977 return _serde::__private::Err(
978 <__A::Error as _serde::de::Error>::duplicate_field(
979 "numBlocks",
980 ),
981 );
982 }
983 m_numBlocks = _serde::__private::Some(
984 match __A::next_value::<i32>(&mut __map) {
985 _serde::__private::Ok(__val) => __val,
986 _serde::__private::Err(__err) => {
987 return _serde::__private::Err(__err);
988 }
989 },
990 );
991 }
992 __Field::m_maxFramesPerBlock => {
993 #[cfg(
994 any(feature = "strict", feature = "ignore_duplicates")
995 )]
996 if _serde::__private::Option::is_some(
997 &m_maxFramesPerBlock,
998 ) {
999 #[cfg(feature = "ignore_duplicates")]
1000 {
1001 __A::skip_value(&mut __map)?;
1002 continue;
1003 }
1004 #[cfg(feature = "strict")]
1005 return _serde::__private::Err(
1006 <__A::Error as _serde::de::Error>::duplicate_field(
1007 "maxFramesPerBlock",
1008 ),
1009 );
1010 }
1011 m_maxFramesPerBlock = _serde::__private::Some(
1012 match __A::next_value::<i32>(&mut __map) {
1013 _serde::__private::Ok(__val) => __val,
1014 _serde::__private::Err(__err) => {
1015 return _serde::__private::Err(__err);
1016 }
1017 },
1018 );
1019 }
1020 __Field::m_maskAndQuantizationSize => {
1021 #[cfg(
1022 any(feature = "strict", feature = "ignore_duplicates")
1023 )]
1024 if _serde::__private::Option::is_some(
1025 &m_maskAndQuantizationSize,
1026 ) {
1027 #[cfg(feature = "ignore_duplicates")]
1028 {
1029 __A::skip_value(&mut __map)?;
1030 continue;
1031 }
1032 #[cfg(feature = "strict")]
1033 return _serde::__private::Err(
1034 <__A::Error as _serde::de::Error>::duplicate_field(
1035 "maskAndQuantizationSize",
1036 ),
1037 );
1038 }
1039 m_maskAndQuantizationSize = _serde::__private::Some(
1040 match __A::next_value::<i32>(&mut __map) {
1041 _serde::__private::Ok(__val) => __val,
1042 _serde::__private::Err(__err) => {
1043 return _serde::__private::Err(__err);
1044 }
1045 },
1046 );
1047 }
1048 __Field::m_blockDuration => {
1049 #[cfg(
1050 any(feature = "strict", feature = "ignore_duplicates")
1051 )]
1052 if _serde::__private::Option::is_some(&m_blockDuration) {
1053 #[cfg(feature = "ignore_duplicates")]
1054 {
1055 __A::skip_value(&mut __map)?;
1056 continue;
1057 }
1058 #[cfg(feature = "strict")]
1059 return _serde::__private::Err(
1060 <__A::Error as _serde::de::Error>::duplicate_field(
1061 "blockDuration",
1062 ),
1063 );
1064 }
1065 m_blockDuration = _serde::__private::Some(
1066 match __A::next_value::<f32>(&mut __map) {
1067 _serde::__private::Ok(__val) => __val,
1068 _serde::__private::Err(__err) => {
1069 return _serde::__private::Err(__err);
1070 }
1071 },
1072 );
1073 }
1074 __Field::m_blockInverseDuration => {
1075 #[cfg(
1076 any(feature = "strict", feature = "ignore_duplicates")
1077 )]
1078 if _serde::__private::Option::is_some(
1079 &m_blockInverseDuration,
1080 ) {
1081 #[cfg(feature = "ignore_duplicates")]
1082 {
1083 __A::skip_value(&mut __map)?;
1084 continue;
1085 }
1086 #[cfg(feature = "strict")]
1087 return _serde::__private::Err(
1088 <__A::Error as _serde::de::Error>::duplicate_field(
1089 "blockInverseDuration",
1090 ),
1091 );
1092 }
1093 m_blockInverseDuration = _serde::__private::Some(
1094 match __A::next_value::<f32>(&mut __map) {
1095 _serde::__private::Ok(__val) => __val,
1096 _serde::__private::Err(__err) => {
1097 return _serde::__private::Err(__err);
1098 }
1099 },
1100 );
1101 }
1102 __Field::m_frameDuration => {
1103 #[cfg(
1104 any(feature = "strict", feature = "ignore_duplicates")
1105 )]
1106 if _serde::__private::Option::is_some(&m_frameDuration) {
1107 #[cfg(feature = "ignore_duplicates")]
1108 {
1109 __A::skip_value(&mut __map)?;
1110 continue;
1111 }
1112 #[cfg(feature = "strict")]
1113 return _serde::__private::Err(
1114 <__A::Error as _serde::de::Error>::duplicate_field(
1115 "frameDuration",
1116 ),
1117 );
1118 }
1119 m_frameDuration = _serde::__private::Some(
1120 match __A::next_value::<f32>(&mut __map) {
1121 _serde::__private::Ok(__val) => __val,
1122 _serde::__private::Err(__err) => {
1123 return _serde::__private::Err(__err);
1124 }
1125 },
1126 );
1127 }
1128 __Field::m_blockOffsets => {
1129 #[cfg(
1130 any(feature = "strict", feature = "ignore_duplicates")
1131 )]
1132 if _serde::__private::Option::is_some(&m_blockOffsets) {
1133 #[cfg(feature = "ignore_duplicates")]
1134 {
1135 __A::skip_value(&mut __map)?;
1136 continue;
1137 }
1138 #[cfg(feature = "strict")]
1139 return _serde::__private::Err(
1140 <__A::Error as _serde::de::Error>::duplicate_field(
1141 "blockOffsets",
1142 ),
1143 );
1144 }
1145 m_blockOffsets = _serde::__private::Some(
1146 match __A::next_value::<Vec<u32>>(&mut __map) {
1147 _serde::__private::Ok(__val) => __val,
1148 _serde::__private::Err(__err) => {
1149 return _serde::__private::Err(__err);
1150 }
1151 },
1152 );
1153 }
1154 __Field::m_floatBlockOffsets => {
1155 #[cfg(
1156 any(feature = "strict", feature = "ignore_duplicates")
1157 )]
1158 if _serde::__private::Option::is_some(
1159 &m_floatBlockOffsets,
1160 ) {
1161 #[cfg(feature = "ignore_duplicates")]
1162 {
1163 __A::skip_value(&mut __map)?;
1164 continue;
1165 }
1166 #[cfg(feature = "strict")]
1167 return _serde::__private::Err(
1168 <__A::Error as _serde::de::Error>::duplicate_field(
1169 "floatBlockOffsets",
1170 ),
1171 );
1172 }
1173 m_floatBlockOffsets = _serde::__private::Some(
1174 match __A::next_value::<Vec<u32>>(&mut __map) {
1175 _serde::__private::Ok(__val) => __val,
1176 _serde::__private::Err(__err) => {
1177 return _serde::__private::Err(__err);
1178 }
1179 },
1180 );
1181 }
1182 __Field::m_transformOffsets => {
1183 #[cfg(
1184 any(feature = "strict", feature = "ignore_duplicates")
1185 )]
1186 if _serde::__private::Option::is_some(&m_transformOffsets) {
1187 #[cfg(feature = "ignore_duplicates")]
1188 {
1189 __A::skip_value(&mut __map)?;
1190 continue;
1191 }
1192 #[cfg(feature = "strict")]
1193 return _serde::__private::Err(
1194 <__A::Error as _serde::de::Error>::duplicate_field(
1195 "transformOffsets",
1196 ),
1197 );
1198 }
1199 m_transformOffsets = _serde::__private::Some(
1200 match __A::next_value::<Vec<u32>>(&mut __map) {
1201 _serde::__private::Ok(__val) => __val,
1202 _serde::__private::Err(__err) => {
1203 return _serde::__private::Err(__err);
1204 }
1205 },
1206 );
1207 }
1208 __Field::m_floatOffsets => {
1209 #[cfg(
1210 any(feature = "strict", feature = "ignore_duplicates")
1211 )]
1212 if _serde::__private::Option::is_some(&m_floatOffsets) {
1213 #[cfg(feature = "ignore_duplicates")]
1214 {
1215 __A::skip_value(&mut __map)?;
1216 continue;
1217 }
1218 #[cfg(feature = "strict")]
1219 return _serde::__private::Err(
1220 <__A::Error as _serde::de::Error>::duplicate_field(
1221 "floatOffsets",
1222 ),
1223 );
1224 }
1225 m_floatOffsets = _serde::__private::Some(
1226 match __A::next_value::<Vec<u32>>(&mut __map) {
1227 _serde::__private::Ok(__val) => __val,
1228 _serde::__private::Err(__err) => {
1229 return _serde::__private::Err(__err);
1230 }
1231 },
1232 );
1233 }
1234 __Field::m_data => {
1235 #[cfg(
1236 any(feature = "strict", feature = "ignore_duplicates")
1237 )]
1238 if _serde::__private::Option::is_some(&m_data) {
1239 #[cfg(feature = "ignore_duplicates")]
1240 {
1241 __A::skip_value(&mut __map)?;
1242 continue;
1243 }
1244 #[cfg(feature = "strict")]
1245 return _serde::__private::Err(
1246 <__A::Error as _serde::de::Error>::duplicate_field("data"),
1247 );
1248 }
1249 m_data = _serde::__private::Some(
1250 match __A::next_value::<Vec<u8>>(&mut __map) {
1251 _serde::__private::Ok(__val) => __val,
1252 _serde::__private::Err(__err) => {
1253 return _serde::__private::Err(__err);
1254 }
1255 },
1256 );
1257 }
1258 __Field::m_endian => {
1259 #[cfg(
1260 any(feature = "strict", feature = "ignore_duplicates")
1261 )]
1262 if _serde::__private::Option::is_some(&m_endian) {
1263 #[cfg(feature = "ignore_duplicates")]
1264 {
1265 __A::skip_value(&mut __map)?;
1266 continue;
1267 }
1268 #[cfg(feature = "strict")]
1269 return _serde::__private::Err(
1270 <__A::Error as _serde::de::Error>::duplicate_field("endian"),
1271 );
1272 }
1273 m_endian = _serde::__private::Some(
1274 match __A::next_value::<i32>(&mut __map) {
1275 _serde::__private::Ok(__val) => __val,
1276 _serde::__private::Err(__err) => {
1277 return _serde::__private::Err(__err);
1278 }
1279 },
1280 );
1281 }
1282 _ => __A::skip_value(&mut __map)?,
1283 }
1284 }
1285 let m_type = match m_type {
1286 _serde::__private::Some(__field) => __field,
1287 _serde::__private::None => {
1288 #[cfg(feature = "strict")]
1289 return _serde::__private::Err(
1290 <__A::Error as _serde::de::Error>::missing_field("type"),
1291 );
1292 #[cfg(not(feature = "strict"))] Default::default()
1293 }
1294 };
1295 let m_duration = match m_duration {
1296 _serde::__private::Some(__field) => __field,
1297 _serde::__private::None => {
1298 #[cfg(feature = "strict")]
1299 return _serde::__private::Err(
1300 <__A::Error as _serde::de::Error>::missing_field("duration"),
1301 );
1302 #[cfg(not(feature = "strict"))] Default::default()
1303 }
1304 };
1305 let m_numberOfTransformTracks = match m_numberOfTransformTracks {
1306 _serde::__private::Some(__field) => __field,
1307 _serde::__private::None => {
1308 #[cfg(feature = "strict")]
1309 return _serde::__private::Err(
1310 <__A::Error as _serde::de::Error>::missing_field(
1311 "numberOfTransformTracks",
1312 ),
1313 );
1314 #[cfg(not(feature = "strict"))] Default::default()
1315 }
1316 };
1317 let m_numberOfFloatTracks = match m_numberOfFloatTracks {
1318 _serde::__private::Some(__field) => __field,
1319 _serde::__private::None => {
1320 #[cfg(feature = "strict")]
1321 return _serde::__private::Err(
1322 <__A::Error as _serde::de::Error>::missing_field(
1323 "numberOfFloatTracks",
1324 ),
1325 );
1326 #[cfg(not(feature = "strict"))] Default::default()
1327 }
1328 };
1329 let m_extractedMotion = match m_extractedMotion {
1330 _serde::__private::Some(__field) => __field,
1331 _serde::__private::None => {
1332 #[cfg(feature = "strict")]
1333 return _serde::__private::Err(
1334 <__A::Error as _serde::de::Error>::missing_field(
1335 "extractedMotion",
1336 ),
1337 );
1338 #[cfg(not(feature = "strict"))] Default::default()
1339 }
1340 };
1341 let m_annotationTracks = match m_annotationTracks {
1342 _serde::__private::Some(__field) => __field,
1343 _serde::__private::None => {
1344 #[cfg(feature = "strict")]
1345 return _serde::__private::Err(
1346 <__A::Error as _serde::de::Error>::missing_field(
1347 "annotationTracks",
1348 ),
1349 );
1350 #[cfg(not(feature = "strict"))] Default::default()
1351 }
1352 };
1353 let m_numFrames = match m_numFrames {
1354 _serde::__private::Some(__field) => __field,
1355 _serde::__private::None => {
1356 #[cfg(feature = "strict")]
1357 return _serde::__private::Err(
1358 <__A::Error as _serde::de::Error>::missing_field(
1359 "numFrames",
1360 ),
1361 );
1362 #[cfg(not(feature = "strict"))] Default::default()
1363 }
1364 };
1365 let m_numBlocks = match m_numBlocks {
1366 _serde::__private::Some(__field) => __field,
1367 _serde::__private::None => {
1368 #[cfg(feature = "strict")]
1369 return _serde::__private::Err(
1370 <__A::Error as _serde::de::Error>::missing_field(
1371 "numBlocks",
1372 ),
1373 );
1374 #[cfg(not(feature = "strict"))] Default::default()
1375 }
1376 };
1377 let m_maxFramesPerBlock = match m_maxFramesPerBlock {
1378 _serde::__private::Some(__field) => __field,
1379 _serde::__private::None => {
1380 #[cfg(feature = "strict")]
1381 return _serde::__private::Err(
1382 <__A::Error as _serde::de::Error>::missing_field(
1383 "maxFramesPerBlock",
1384 ),
1385 );
1386 #[cfg(not(feature = "strict"))] Default::default()
1387 }
1388 };
1389 let m_maskAndQuantizationSize = match m_maskAndQuantizationSize {
1390 _serde::__private::Some(__field) => __field,
1391 _serde::__private::None => {
1392 #[cfg(feature = "strict")]
1393 return _serde::__private::Err(
1394 <__A::Error as _serde::de::Error>::missing_field(
1395 "maskAndQuantizationSize",
1396 ),
1397 );
1398 #[cfg(not(feature = "strict"))] Default::default()
1399 }
1400 };
1401 let m_blockDuration = match m_blockDuration {
1402 _serde::__private::Some(__field) => __field,
1403 _serde::__private::None => {
1404 #[cfg(feature = "strict")]
1405 return _serde::__private::Err(
1406 <__A::Error as _serde::de::Error>::missing_field(
1407 "blockDuration",
1408 ),
1409 );
1410 #[cfg(not(feature = "strict"))] Default::default()
1411 }
1412 };
1413 let m_blockInverseDuration = match m_blockInverseDuration {
1414 _serde::__private::Some(__field) => __field,
1415 _serde::__private::None => {
1416 #[cfg(feature = "strict")]
1417 return _serde::__private::Err(
1418 <__A::Error as _serde::de::Error>::missing_field(
1419 "blockInverseDuration",
1420 ),
1421 );
1422 #[cfg(not(feature = "strict"))] Default::default()
1423 }
1424 };
1425 let m_frameDuration = match m_frameDuration {
1426 _serde::__private::Some(__field) => __field,
1427 _serde::__private::None => {
1428 #[cfg(feature = "strict")]
1429 return _serde::__private::Err(
1430 <__A::Error as _serde::de::Error>::missing_field(
1431 "frameDuration",
1432 ),
1433 );
1434 #[cfg(not(feature = "strict"))] Default::default()
1435 }
1436 };
1437 let m_blockOffsets = match m_blockOffsets {
1438 _serde::__private::Some(__field) => __field,
1439 _serde::__private::None => {
1440 #[cfg(feature = "strict")]
1441 return _serde::__private::Err(
1442 <__A::Error as _serde::de::Error>::missing_field(
1443 "blockOffsets",
1444 ),
1445 );
1446 #[cfg(not(feature = "strict"))] Default::default()
1447 }
1448 };
1449 let m_floatBlockOffsets = match m_floatBlockOffsets {
1450 _serde::__private::Some(__field) => __field,
1451 _serde::__private::None => {
1452 #[cfg(feature = "strict")]
1453 return _serde::__private::Err(
1454 <__A::Error as _serde::de::Error>::missing_field(
1455 "floatBlockOffsets",
1456 ),
1457 );
1458 #[cfg(not(feature = "strict"))] Default::default()
1459 }
1460 };
1461 let m_transformOffsets = match m_transformOffsets {
1462 _serde::__private::Some(__field) => __field,
1463 _serde::__private::None => {
1464 #[cfg(feature = "strict")]
1465 return _serde::__private::Err(
1466 <__A::Error as _serde::de::Error>::missing_field(
1467 "transformOffsets",
1468 ),
1469 );
1470 #[cfg(not(feature = "strict"))] Default::default()
1471 }
1472 };
1473 let m_floatOffsets = match m_floatOffsets {
1474 _serde::__private::Some(__field) => __field,
1475 _serde::__private::None => {
1476 #[cfg(feature = "strict")]
1477 return _serde::__private::Err(
1478 <__A::Error as _serde::de::Error>::missing_field(
1479 "floatOffsets",
1480 ),
1481 );
1482 #[cfg(not(feature = "strict"))] Default::default()
1483 }
1484 };
1485 let m_data = match m_data {
1486 _serde::__private::Some(__field) => __field,
1487 _serde::__private::None => {
1488 #[cfg(feature = "strict")]
1489 return _serde::__private::Err(
1490 <__A::Error as _serde::de::Error>::missing_field("data"),
1491 );
1492 #[cfg(not(feature = "strict"))] Default::default()
1493 }
1494 };
1495 let m_endian = match m_endian {
1496 _serde::__private::Some(__field) => __field,
1497 _serde::__private::None => {
1498 #[cfg(feature = "strict")]
1499 return _serde::__private::Err(
1500 <__A::Error as _serde::de::Error>::missing_field("endian"),
1501 );
1502 #[cfg(not(feature = "strict"))] Default::default()
1503 }
1504 };
1505 let __ptr = None;
1506 let parent = hkBaseObject { __ptr };
1507 let parent = hkReferencedObject {
1508 __ptr,
1509 parent,
1510 ..Default::default()
1511 };
1512 let parent = hkaAnimation {
1513 __ptr,
1514 parent,
1515 m_type,
1516 m_duration,
1517 m_numberOfTransformTracks,
1518 m_numberOfFloatTracks,
1519 m_extractedMotion,
1520 m_annotationTracks,
1521 };
1522 let __ptr = __A::class_ptr(&mut __map);
1523 _serde::__private::Ok(hkaSplineCompressedAnimation {
1524 __ptr,
1525 parent,
1526 m_numFrames,
1527 m_numBlocks,
1528 m_maxFramesPerBlock,
1529 m_maskAndQuantizationSize,
1530 m_blockDuration,
1531 m_blockInverseDuration,
1532 m_frameDuration,
1533 m_blockOffsets,
1534 m_floatBlockOffsets,
1535 m_transformOffsets,
1536 m_floatOffsets,
1537 m_data,
1538 m_endian,
1539 })
1540 }
1541 }
1542 const FIELDS: &[&str] = &[
1543 "numFrames",
1544 "numBlocks",
1545 "maxFramesPerBlock",
1546 "maskAndQuantizationSize",
1547 "blockDuration",
1548 "blockInverseDuration",
1549 "frameDuration",
1550 "blockOffsets",
1551 "floatBlockOffsets",
1552 "transformOffsets",
1553 "floatOffsets",
1554 "data",
1555 "endian",
1556 ];
1557 _serde::Deserializer::deserialize_struct(
1558 deserializer,
1559 "hkaSplineCompressedAnimation",
1560 FIELDS,
1561 __hkaSplineCompressedAnimationVisitor {
1562 marker: _serde::__private::PhantomData::<
1563 hkaSplineCompressedAnimation,
1564 >,
1565 lifetime: _serde::__private::PhantomData,
1566 },
1567 )
1568 }
1569 }
1570};