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