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 hkaSkeleton<'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 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "serde", serde(borrow))]
35 #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
36 #[cfg_attr(feature = "serde", serde(rename = "name"))]
37 pub m_name: StringPtr<'a>,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "parentIndices"))]
43 #[cfg_attr(feature = "serde", serde(rename = "parentIndices"))]
44 pub m_parentIndices: Vec<i16>,
45 #[cfg_attr(feature = "serde", serde(borrow))]
50 #[cfg_attr(feature = "json_schema", schemars(rename = "bones"))]
51 #[cfg_attr(feature = "serde", serde(rename = "bones"))]
52 pub m_bones: Vec<hkaBone<'a>>,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "referencePose"))]
58 #[cfg_attr(feature = "serde", serde(rename = "referencePose"))]
59 pub m_referencePose: Vec<QsTransform>,
60 #[cfg_attr(feature = "json_schema", schemars(rename = "referenceFloats"))]
65 #[cfg_attr(feature = "serde", serde(rename = "referenceFloats"))]
66 pub m_referenceFloats: Vec<f32>,
67 #[cfg_attr(feature = "serde", serde(borrow))]
72 #[cfg_attr(feature = "json_schema", schemars(rename = "floatSlots"))]
73 #[cfg_attr(feature = "serde", serde(rename = "floatSlots"))]
74 pub m_floatSlots: Vec<StringPtr<'a>>,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "localFrames"))]
80 #[cfg_attr(feature = "serde", serde(rename = "localFrames"))]
81 pub m_localFrames: Vec<hkaSkeletonLocalFrameOnBone>,
82}
83const _: () = {
84 use havok_serde as _serde;
85 impl<'a> _serde::HavokClass for hkaSkeleton<'a> {
86 #[inline]
87 fn name(&self) -> &'static str {
88 "hkaSkeleton"
89 }
90 #[inline]
91 fn signature(&self) -> _serde::__private::Signature {
92 _serde::__private::Signature::new(0x366e8220)
93 }
94 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
95 fn deps_indexes(&self) -> Vec<usize> {
96 let mut v = Vec::new();
97 v.extend(
98 self
99 .m_bones
100 .iter()
101 .flat_map(|class| class.deps_indexes())
102 .collect::<Vec<usize>>(),
103 );
104 v.extend(
105 self
106 .m_localFrames
107 .iter()
108 .flat_map(|class| class.deps_indexes())
109 .collect::<Vec<usize>>(),
110 );
111 v
112 }
113 }
114 impl<'a> _serde::Serialize for hkaSkeleton<'a> {
115 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
116 where
117 S: _serde::ser::Serializer,
118 {
119 let class_meta = self
120 .__ptr
121 .map(|name| (name, _serde::__private::Signature::new(0x366e8220)));
122 let mut serializer = __serializer
123 .serialize_struct("hkaSkeleton", class_meta, (84u64, 120u64))?;
124 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
125 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
126 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
127 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
128 serializer.serialize_field("name", &self.m_name)?;
129 serializer
130 .serialize_array_field(
131 "parentIndices",
132 &self.m_parentIndices,
133 TypeSize::NonPtr,
134 )?;
135 serializer
136 .serialize_array_field(
137 "bones",
138 &self.m_bones,
139 TypeSize::Struct {
140 size_x86: 8u64,
141 size_x86_64: 16u64,
142 },
143 )?;
144 serializer
145 .serialize_array_field(
146 "referencePose",
147 &self.m_referencePose,
148 TypeSize::NonPtr,
149 )?;
150 serializer
151 .serialize_array_field(
152 "referenceFloats",
153 &self.m_referenceFloats,
154 TypeSize::NonPtr,
155 )?;
156 serializer
157 .serialize_array_field(
158 "floatSlots",
159 &self.m_floatSlots,
160 TypeSize::String,
161 )?;
162 serializer
163 .serialize_array_field(
164 "localFrames",
165 &self.m_localFrames,
166 TypeSize::Struct {
167 size_x86: 8u64,
168 size_x86_64: 16u64,
169 },
170 )?;
171 serializer.end()
172 }
173 }
174};
175#[doc(hidden)]
176#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
177const _: () = {
178 use havok_serde as _serde;
179 #[automatically_derived]
180 impl<'de> _serde::Deserialize<'de> for hkaSkeleton<'de> {
181 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
182 where
183 __D: _serde::Deserializer<'de>,
184 {
185 #[allow(non_camel_case_types)]
186 enum __Field {
187 m_name,
188 m_parentIndices,
189 m_bones,
190 m_referencePose,
191 m_referenceFloats,
192 m_floatSlots,
193 m_localFrames,
194 __ignore,
195 }
196 struct __FieldVisitor;
197 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
198 type Value = __Field;
199 fn expecting(
200 &self,
201 __formatter: &mut core::fmt::Formatter,
202 ) -> core::fmt::Result {
203 core::fmt::Formatter::write_str(__formatter, "field identifier")
204 }
205 #[allow(clippy::match_single_binding)]
207 #[allow(clippy::reversed_empty_ranges)]
208 #[allow(clippy::single_match)]
209 fn visit_key<__E>(
210 self,
211 __value: &str,
212 ) -> core::result::Result<Self::Value, __E>
213 where
214 __E: _serde::de::Error,
215 {
216 match __value {
217 "name" => Ok(__Field::m_name),
218 "parentIndices" => Ok(__Field::m_parentIndices),
219 "bones" => Ok(__Field::m_bones),
220 "referencePose" => Ok(__Field::m_referencePose),
221 "referenceFloats" => Ok(__Field::m_referenceFloats),
222 "floatSlots" => Ok(__Field::m_floatSlots),
223 "localFrames" => Ok(__Field::m_localFrames),
224 _ => Ok(__Field::__ignore),
225 }
226 }
227 }
228 impl<'de> _serde::Deserialize<'de> for __Field {
229 #[inline]
230 fn deserialize<__D>(
231 __deserializer: __D,
232 ) -> core::result::Result<Self, __D::Error>
233 where
234 __D: _serde::Deserializer<'de>,
235 {
236 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
237 }
238 }
239 struct __hkaSkeletonVisitor<'de> {
240 marker: _serde::__private::PhantomData<hkaSkeleton<'de>>,
241 lifetime: _serde::__private::PhantomData<&'de ()>,
242 }
243 #[allow(clippy::match_single_binding)]
244 #[allow(clippy::reversed_empty_ranges)]
245 #[allow(clippy::single_match)]
246 impl<'de> _serde::de::Visitor<'de> for __hkaSkeletonVisitor<'de> {
247 type Value = hkaSkeleton<'de>;
248 fn expecting(
249 &self,
250 __formatter: &mut core::fmt::Formatter,
251 ) -> core::fmt::Result {
252 core::fmt::Formatter::write_str(__formatter, "struct hkaSkeleton")
253 }
254 fn visit_struct_for_bytes<__A>(
255 self,
256 mut __map: __A,
257 ) -> _serde::__private::Result<Self::Value, __A::Error>
258 where
259 __A: _serde::de::MapAccess<'de>,
260 {
261 let __ptr = __A::class_ptr(&mut __map);
262 let parent = __A::parent_value(&mut __map)?;
263 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
264 let mut m_parentIndices: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
265 let mut m_bones: _serde::__private::Option<Vec<hkaBone<'de>>> = _serde::__private::None;
266 let mut m_referencePose: _serde::__private::Option<
267 Vec<QsTransform>,
268 > = _serde::__private::None;
269 let mut m_referenceFloats: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
270 let mut m_floatSlots: _serde::__private::Option<
271 Vec<StringPtr<'de>>,
272 > = _serde::__private::None;
273 let mut m_localFrames: _serde::__private::Option<
274 Vec<hkaSkeletonLocalFrameOnBone>,
275 > = _serde::__private::None;
276 for i in 0..7usize {
277 match i {
278 0usize => {
279 if _serde::__private::Option::is_some(&m_name) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field("name"),
282 );
283 }
284 m_name = _serde::__private::Some(
285 match __A::next_value::<StringPtr<'de>>(&mut __map) {
286 _serde::__private::Ok(__val) => __val,
287 _serde::__private::Err(__err) => {
288 return _serde::__private::Err(__err);
289 }
290 },
291 );
292 }
293 1usize => {
294 if _serde::__private::Option::is_some(&m_parentIndices) {
295 return _serde::__private::Err(
296 <__A::Error as _serde::de::Error>::duplicate_field(
297 "parentIndices",
298 ),
299 );
300 }
301 m_parentIndices = _serde::__private::Some(
302 match __A::next_value::<Vec<i16>>(&mut __map) {
303 _serde::__private::Ok(__val) => __val,
304 _serde::__private::Err(__err) => {
305 return _serde::__private::Err(__err);
306 }
307 },
308 );
309 }
310 2usize => {
311 if _serde::__private::Option::is_some(&m_bones) {
312 return _serde::__private::Err(
313 <__A::Error as _serde::de::Error>::duplicate_field("bones"),
314 );
315 }
316 m_bones = _serde::__private::Some(
317 match __A::next_value::<Vec<hkaBone<'de>>>(&mut __map) {
318 _serde::__private::Ok(__val) => __val,
319 _serde::__private::Err(__err) => {
320 return _serde::__private::Err(__err);
321 }
322 },
323 );
324 }
325 3usize => {
326 if _serde::__private::Option::is_some(&m_referencePose) {
327 return _serde::__private::Err(
328 <__A::Error as _serde::de::Error>::duplicate_field(
329 "referencePose",
330 ),
331 );
332 }
333 m_referencePose = _serde::__private::Some(
334 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
335 _serde::__private::Ok(__val) => __val,
336 _serde::__private::Err(__err) => {
337 return _serde::__private::Err(__err);
338 }
339 },
340 );
341 }
342 4usize => {
343 if _serde::__private::Option::is_some(&m_referenceFloats) {
344 return _serde::__private::Err(
345 <__A::Error as _serde::de::Error>::duplicate_field(
346 "referenceFloats",
347 ),
348 );
349 }
350 m_referenceFloats = _serde::__private::Some(
351 match __A::next_value::<Vec<f32>>(&mut __map) {
352 _serde::__private::Ok(__val) => __val,
353 _serde::__private::Err(__err) => {
354 return _serde::__private::Err(__err);
355 }
356 },
357 );
358 }
359 5usize => {
360 if _serde::__private::Option::is_some(&m_floatSlots) {
361 return _serde::__private::Err(
362 <__A::Error as _serde::de::Error>::duplicate_field(
363 "floatSlots",
364 ),
365 );
366 }
367 m_floatSlots = _serde::__private::Some(
368 match __A::next_value::<Vec<StringPtr<'de>>>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 6usize => {
377 if _serde::__private::Option::is_some(&m_localFrames) {
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field(
380 "localFrames",
381 ),
382 );
383 }
384 m_localFrames = _serde::__private::Some(
385 match __A::next_value::<
386 Vec<hkaSkeletonLocalFrameOnBone>,
387 >(&mut __map) {
388 _serde::__private::Ok(__val) => __val,
389 _serde::__private::Err(__err) => {
390 return _serde::__private::Err(__err);
391 }
392 },
393 );
394 }
395 _ => {}
396 }
397 }
398 let m_name = match m_name {
399 _serde::__private::Some(__field) => __field,
400 _serde::__private::None => {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::missing_field("name"),
403 );
404 }
405 };
406 let m_parentIndices = match m_parentIndices {
407 _serde::__private::Some(__field) => __field,
408 _serde::__private::None => {
409 return _serde::__private::Err(
410 <__A::Error as _serde::de::Error>::missing_field(
411 "parentIndices",
412 ),
413 );
414 }
415 };
416 let m_bones = match m_bones {
417 _serde::__private::Some(__field) => __field,
418 _serde::__private::None => {
419 return _serde::__private::Err(
420 <__A::Error as _serde::de::Error>::missing_field("bones"),
421 );
422 }
423 };
424 let m_referencePose = match m_referencePose {
425 _serde::__private::Some(__field) => __field,
426 _serde::__private::None => {
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::missing_field(
429 "referencePose",
430 ),
431 );
432 }
433 };
434 let m_referenceFloats = match m_referenceFloats {
435 _serde::__private::Some(__field) => __field,
436 _serde::__private::None => {
437 return _serde::__private::Err(
438 <__A::Error as _serde::de::Error>::missing_field(
439 "referenceFloats",
440 ),
441 );
442 }
443 };
444 let m_floatSlots = match m_floatSlots {
445 _serde::__private::Some(__field) => __field,
446 _serde::__private::None => {
447 return _serde::__private::Err(
448 <__A::Error as _serde::de::Error>::missing_field(
449 "floatSlots",
450 ),
451 );
452 }
453 };
454 let m_localFrames = match m_localFrames {
455 _serde::__private::Some(__field) => __field,
456 _serde::__private::None => {
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::missing_field(
459 "localFrames",
460 ),
461 );
462 }
463 };
464 _serde::__private::Ok(hkaSkeleton {
465 __ptr,
466 parent,
467 m_name,
468 m_parentIndices,
469 m_bones,
470 m_referencePose,
471 m_referenceFloats,
472 m_floatSlots,
473 m_localFrames,
474 })
475 }
476 #[allow(clippy::manual_unwrap_or_default)]
477 fn visit_struct<__A>(
478 self,
479 mut __map: __A,
480 ) -> _serde::__private::Result<Self::Value, __A::Error>
481 where
482 __A: _serde::de::MapAccess<'de>,
483 {
484 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
485 let mut m_parentIndices: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
486 let mut m_bones: _serde::__private::Option<Vec<hkaBone<'de>>> = _serde::__private::None;
487 let mut m_referencePose: _serde::__private::Option<
488 Vec<QsTransform>,
489 > = _serde::__private::None;
490 let mut m_referenceFloats: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
491 let mut m_floatSlots: _serde::__private::Option<
492 Vec<StringPtr<'de>>,
493 > = _serde::__private::None;
494 let mut m_localFrames: _serde::__private::Option<
495 Vec<hkaSkeletonLocalFrameOnBone>,
496 > = _serde::__private::None;
497 while let _serde::__private::Some(__key) = {
498 __A::next_key::<__Field>(&mut __map)?
499 } {
500 match __key {
501 __Field::m_name => {
502 #[cfg(
503 any(feature = "strict", feature = "ignore_duplicates")
504 )]
505 if _serde::__private::Option::is_some(&m_name) {
506 #[cfg(feature = "ignore_duplicates")]
507 {
508 __A::skip_value(&mut __map)?;
509 continue;
510 }
511 #[cfg(feature = "strict")]
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::duplicate_field("name"),
514 );
515 }
516 m_name = _serde::__private::Some(
517 match __A::next_value::<StringPtr<'de>>(&mut __map) {
518 _serde::__private::Ok(__val) => __val,
519 _serde::__private::Err(__err) => {
520 return _serde::__private::Err(__err);
521 }
522 },
523 );
524 }
525 __Field::m_parentIndices => {
526 #[cfg(
527 any(feature = "strict", feature = "ignore_duplicates")
528 )]
529 if _serde::__private::Option::is_some(&m_parentIndices) {
530 #[cfg(feature = "ignore_duplicates")]
531 {
532 __A::skip_value(&mut __map)?;
533 continue;
534 }
535 #[cfg(feature = "strict")]
536 return _serde::__private::Err(
537 <__A::Error as _serde::de::Error>::duplicate_field(
538 "parentIndices",
539 ),
540 );
541 }
542 m_parentIndices = _serde::__private::Some(
543 match __A::next_value::<Vec<i16>>(&mut __map) {
544 _serde::__private::Ok(__val) => __val,
545 _serde::__private::Err(__err) => {
546 return _serde::__private::Err(__err);
547 }
548 },
549 );
550 }
551 __Field::m_bones => {
552 #[cfg(
553 any(feature = "strict", feature = "ignore_duplicates")
554 )]
555 if _serde::__private::Option::is_some(&m_bones) {
556 #[cfg(feature = "ignore_duplicates")]
557 {
558 __A::skip_value(&mut __map)?;
559 continue;
560 }
561 #[cfg(feature = "strict")]
562 return _serde::__private::Err(
563 <__A::Error as _serde::de::Error>::duplicate_field("bones"),
564 );
565 }
566 m_bones = _serde::__private::Some(
567 match __A::next_value::<Vec<hkaBone<'de>>>(&mut __map) {
568 _serde::__private::Ok(__val) => __val,
569 _serde::__private::Err(__err) => {
570 return _serde::__private::Err(__err);
571 }
572 },
573 );
574 }
575 __Field::m_referencePose => {
576 #[cfg(
577 any(feature = "strict", feature = "ignore_duplicates")
578 )]
579 if _serde::__private::Option::is_some(&m_referencePose) {
580 #[cfg(feature = "ignore_duplicates")]
581 {
582 __A::skip_value(&mut __map)?;
583 continue;
584 }
585 #[cfg(feature = "strict")]
586 return _serde::__private::Err(
587 <__A::Error as _serde::de::Error>::duplicate_field(
588 "referencePose",
589 ),
590 );
591 }
592 m_referencePose = _serde::__private::Some(
593 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
594 _serde::__private::Ok(__val) => __val,
595 _serde::__private::Err(__err) => {
596 return _serde::__private::Err(__err);
597 }
598 },
599 );
600 }
601 __Field::m_referenceFloats => {
602 #[cfg(
603 any(feature = "strict", feature = "ignore_duplicates")
604 )]
605 if _serde::__private::Option::is_some(&m_referenceFloats) {
606 #[cfg(feature = "ignore_duplicates")]
607 {
608 __A::skip_value(&mut __map)?;
609 continue;
610 }
611 #[cfg(feature = "strict")]
612 return _serde::__private::Err(
613 <__A::Error as _serde::de::Error>::duplicate_field(
614 "referenceFloats",
615 ),
616 );
617 }
618 m_referenceFloats = _serde::__private::Some(
619 match __A::next_value::<Vec<f32>>(&mut __map) {
620 _serde::__private::Ok(__val) => __val,
621 _serde::__private::Err(__err) => {
622 return _serde::__private::Err(__err);
623 }
624 },
625 );
626 }
627 __Field::m_floatSlots => {
628 #[cfg(
629 any(feature = "strict", feature = "ignore_duplicates")
630 )]
631 if _serde::__private::Option::is_some(&m_floatSlots) {
632 #[cfg(feature = "ignore_duplicates")]
633 {
634 __A::skip_value(&mut __map)?;
635 continue;
636 }
637 #[cfg(feature = "strict")]
638 return _serde::__private::Err(
639 <__A::Error as _serde::de::Error>::duplicate_field(
640 "floatSlots",
641 ),
642 );
643 }
644 m_floatSlots = _serde::__private::Some(
645 match __A::next_value::<Vec<StringPtr<'de>>>(&mut __map) {
646 _serde::__private::Ok(__val) => __val,
647 _serde::__private::Err(__err) => {
648 return _serde::__private::Err(__err);
649 }
650 },
651 );
652 }
653 __Field::m_localFrames => {
654 #[cfg(
655 any(feature = "strict", feature = "ignore_duplicates")
656 )]
657 if _serde::__private::Option::is_some(&m_localFrames) {
658 #[cfg(feature = "ignore_duplicates")]
659 {
660 __A::skip_value(&mut __map)?;
661 continue;
662 }
663 #[cfg(feature = "strict")]
664 return _serde::__private::Err(
665 <__A::Error as _serde::de::Error>::duplicate_field(
666 "localFrames",
667 ),
668 );
669 }
670 m_localFrames = _serde::__private::Some(
671 match __A::next_value::<
672 Vec<hkaSkeletonLocalFrameOnBone>,
673 >(&mut __map) {
674 _serde::__private::Ok(__val) => __val,
675 _serde::__private::Err(__err) => {
676 return _serde::__private::Err(__err);
677 }
678 },
679 );
680 }
681 _ => __A::skip_value(&mut __map)?,
682 }
683 }
684 let m_name = match m_name {
685 _serde::__private::Some(__field) => __field,
686 _serde::__private::None => {
687 #[cfg(feature = "strict")]
688 return _serde::__private::Err(
689 <__A::Error as _serde::de::Error>::missing_field("name"),
690 );
691 #[cfg(not(feature = "strict"))] Default::default()
692 }
693 };
694 let m_parentIndices = match m_parentIndices {
695 _serde::__private::Some(__field) => __field,
696 _serde::__private::None => {
697 #[cfg(feature = "strict")]
698 return _serde::__private::Err(
699 <__A::Error as _serde::de::Error>::missing_field(
700 "parentIndices",
701 ),
702 );
703 #[cfg(not(feature = "strict"))] Default::default()
704 }
705 };
706 let m_bones = match m_bones {
707 _serde::__private::Some(__field) => __field,
708 _serde::__private::None => {
709 #[cfg(feature = "strict")]
710 return _serde::__private::Err(
711 <__A::Error as _serde::de::Error>::missing_field("bones"),
712 );
713 #[cfg(not(feature = "strict"))] Default::default()
714 }
715 };
716 let m_referencePose = match m_referencePose {
717 _serde::__private::Some(__field) => __field,
718 _serde::__private::None => {
719 #[cfg(feature = "strict")]
720 return _serde::__private::Err(
721 <__A::Error as _serde::de::Error>::missing_field(
722 "referencePose",
723 ),
724 );
725 #[cfg(not(feature = "strict"))] Default::default()
726 }
727 };
728 let m_referenceFloats = match m_referenceFloats {
729 _serde::__private::Some(__field) => __field,
730 _serde::__private::None => {
731 #[cfg(feature = "strict")]
732 return _serde::__private::Err(
733 <__A::Error as _serde::de::Error>::missing_field(
734 "referenceFloats",
735 ),
736 );
737 #[cfg(not(feature = "strict"))] Default::default()
738 }
739 };
740 let m_floatSlots = match m_floatSlots {
741 _serde::__private::Some(__field) => __field,
742 _serde::__private::None => {
743 #[cfg(feature = "strict")]
744 return _serde::__private::Err(
745 <__A::Error as _serde::de::Error>::missing_field(
746 "floatSlots",
747 ),
748 );
749 #[cfg(not(feature = "strict"))] Default::default()
750 }
751 };
752 let m_localFrames = match m_localFrames {
753 _serde::__private::Some(__field) => __field,
754 _serde::__private::None => {
755 #[cfg(feature = "strict")]
756 return _serde::__private::Err(
757 <__A::Error as _serde::de::Error>::missing_field(
758 "localFrames",
759 ),
760 );
761 #[cfg(not(feature = "strict"))] Default::default()
762 }
763 };
764 let __ptr = None;
765 let parent = hkBaseObject { __ptr };
766 let parent = hkReferencedObject {
767 __ptr,
768 parent,
769 ..Default::default()
770 };
771 let __ptr = __A::class_ptr(&mut __map);
772 _serde::__private::Ok(hkaSkeleton {
773 __ptr,
774 parent,
775 m_name,
776 m_parentIndices,
777 m_bones,
778 m_referencePose,
779 m_referenceFloats,
780 m_floatSlots,
781 m_localFrames,
782 })
783 }
784 }
785 const FIELDS: &[&str] = &[
786 "name",
787 "parentIndices",
788 "bones",
789 "referencePose",
790 "referenceFloats",
791 "floatSlots",
792 "localFrames",
793 ];
794 _serde::Deserializer::deserialize_struct(
795 deserializer,
796 "hkaSkeleton",
797 FIELDS,
798 __hkaSkeletonVisitor {
799 marker: _serde::__private::PhantomData::<hkaSkeleton>,
800 lifetime: _serde::__private::PhantomData,
801 },
802 )
803 }
804 }
805};