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