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