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 hkaSkeletonMapperData {
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(rename = "skeletonA"))]
31 #[cfg_attr(feature = "serde", serde(rename = "skeletonA"))]
32 pub m_skeletonA: Pointer,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "skeletonB"))]
38 #[cfg_attr(feature = "serde", serde(rename = "skeletonB"))]
39 pub m_skeletonB: Pointer,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "simpleMappings"))]
45 #[cfg_attr(feature = "serde", serde(rename = "simpleMappings"))]
46 pub m_simpleMappings: Vec<hkaSkeletonMapperDataSimpleMapping>,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "chainMappings"))]
52 #[cfg_attr(feature = "serde", serde(rename = "chainMappings"))]
53 pub m_chainMappings: Vec<hkaSkeletonMapperDataChainMapping>,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "unmappedBones"))]
59 #[cfg_attr(feature = "serde", serde(rename = "unmappedBones"))]
60 pub m_unmappedBones: Vec<i16>,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "extractedMotionMapping"))]
66 #[cfg_attr(feature = "serde", serde(rename = "extractedMotionMapping"))]
67 pub m_extractedMotionMapping: QsTransform,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "keepUnmappedLocal"))]
73 #[cfg_attr(feature = "serde", serde(rename = "keepUnmappedLocal"))]
74 pub m_keepUnmappedLocal: bool,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "mappingType"))]
80 #[cfg_attr(feature = "serde", serde(rename = "mappingType"))]
81 pub m_mappingType: MappingType,
82}
83const _: () = {
84 use havok_serde as _serde;
85 impl _serde::HavokClass for hkaSkeletonMapperData {
86 #[inline]
87 fn name(&self) -> &'static str {
88 "hkaSkeletonMapperData"
89 }
90 #[inline]
91 fn signature(&self) -> _serde::__private::Signature {
92 _serde::__private::Signature::new(0x95687ea0)
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.push(self.m_skeletonA.get());
98 v.push(self.m_skeletonB.get());
99 v.extend(
100 self
101 .m_simpleMappings
102 .iter()
103 .flat_map(|class| class.deps_indexes())
104 .collect::<Vec<usize>>(),
105 );
106 v.extend(
107 self
108 .m_chainMappings
109 .iter()
110 .flat_map(|class| class.deps_indexes())
111 .collect::<Vec<usize>>(),
112 );
113 v
114 }
115 }
116 impl _serde::Serialize for hkaSkeletonMapperData {
117 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
118 where
119 S: _serde::ser::Serializer,
120 {
121 let class_meta = self
122 .__ptr
123 .map(|name| (name, _serde::__private::Signature::new(0x95687ea0)));
124 let mut serializer = __serializer
125 .serialize_struct(
126 "hkaSkeletonMapperData",
127 class_meta,
128 (112u64, 128u64),
129 )?;
130 serializer.serialize_field("skeletonA", &self.m_skeletonA)?;
131 serializer.serialize_field("skeletonB", &self.m_skeletonB)?;
132 serializer
133 .serialize_array_field(
134 "simpleMappings",
135 &self.m_simpleMappings,
136 TypeSize::Struct {
137 size_x86: 64u64,
138 size_x86_64: 64u64,
139 },
140 )?;
141 serializer
142 .serialize_array_field(
143 "chainMappings",
144 &self.m_chainMappings,
145 TypeSize::Struct {
146 size_x86: 112u64,
147 size_x86_64: 112u64,
148 },
149 )?;
150 serializer
151 .serialize_array_field(
152 "unmappedBones",
153 &self.m_unmappedBones,
154 TypeSize::NonPtr,
155 )?;
156 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
157 serializer
158 .serialize_field(
159 "extractedMotionMapping",
160 &self.m_extractedMotionMapping,
161 )?;
162 serializer.serialize_field("keepUnmappedLocal", &self.m_keepUnmappedLocal)?;
163 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
164 serializer.serialize_field("mappingType", &self.m_mappingType)?;
165 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
166 serializer.end()
167 }
168 }
169};
170#[doc(hidden)]
171#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
172const _: () = {
173 use havok_serde as _serde;
174 #[automatically_derived]
175 impl<'de> _serde::Deserialize<'de> for hkaSkeletonMapperData {
176 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
177 where
178 __D: _serde::Deserializer<'de>,
179 {
180 #[allow(non_camel_case_types)]
181 enum __Field {
182 m_skeletonA,
183 m_skeletonB,
184 m_simpleMappings,
185 m_chainMappings,
186 m_unmappedBones,
187 m_extractedMotionMapping,
188 m_keepUnmappedLocal,
189 m_mappingType,
190 __ignore,
191 }
192 struct __FieldVisitor;
193 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
194 type Value = __Field;
195 fn expecting(
196 &self,
197 __formatter: &mut core::fmt::Formatter,
198 ) -> core::fmt::Result {
199 core::fmt::Formatter::write_str(__formatter, "field identifier")
200 }
201 #[allow(clippy::match_single_binding)]
203 #[allow(clippy::reversed_empty_ranges)]
204 #[allow(clippy::single_match)]
205 fn visit_key<__E>(
206 self,
207 __value: &str,
208 ) -> core::result::Result<Self::Value, __E>
209 where
210 __E: _serde::de::Error,
211 {
212 match __value {
213 "skeletonA" => Ok(__Field::m_skeletonA),
214 "skeletonB" => Ok(__Field::m_skeletonB),
215 "simpleMappings" => Ok(__Field::m_simpleMappings),
216 "chainMappings" => Ok(__Field::m_chainMappings),
217 "unmappedBones" => Ok(__Field::m_unmappedBones),
218 "extractedMotionMapping" => Ok(__Field::m_extractedMotionMapping),
219 "keepUnmappedLocal" => Ok(__Field::m_keepUnmappedLocal),
220 "mappingType" => Ok(__Field::m_mappingType),
221 _ => Ok(__Field::__ignore),
222 }
223 }
224 }
225 impl<'de> _serde::Deserialize<'de> for __Field {
226 #[inline]
227 fn deserialize<__D>(
228 __deserializer: __D,
229 ) -> core::result::Result<Self, __D::Error>
230 where
231 __D: _serde::Deserializer<'de>,
232 {
233 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
234 }
235 }
236 struct __hkaSkeletonMapperDataVisitor<'de> {
237 marker: _serde::__private::PhantomData<hkaSkeletonMapperData>,
238 lifetime: _serde::__private::PhantomData<&'de ()>,
239 }
240 #[allow(clippy::match_single_binding)]
241 #[allow(clippy::reversed_empty_ranges)]
242 #[allow(clippy::single_match)]
243 impl<'de> _serde::de::Visitor<'de> for __hkaSkeletonMapperDataVisitor<'de> {
244 type Value = hkaSkeletonMapperData;
245 fn expecting(
246 &self,
247 __formatter: &mut core::fmt::Formatter,
248 ) -> core::fmt::Result {
249 core::fmt::Formatter::write_str(
250 __formatter,
251 "struct hkaSkeletonMapperData",
252 )
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 mut m_skeletonA: _serde::__private::Option<Pointer> = _serde::__private::None;
263 let mut m_skeletonB: _serde::__private::Option<Pointer> = _serde::__private::None;
264 let mut m_simpleMappings: _serde::__private::Option<
265 Vec<hkaSkeletonMapperDataSimpleMapping>,
266 > = _serde::__private::None;
267 let mut m_chainMappings: _serde::__private::Option<
268 Vec<hkaSkeletonMapperDataChainMapping>,
269 > = _serde::__private::None;
270 let mut m_unmappedBones: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
271 let mut m_extractedMotionMapping: _serde::__private::Option<
272 QsTransform,
273 > = _serde::__private::None;
274 let mut m_keepUnmappedLocal: _serde::__private::Option<bool> = _serde::__private::None;
275 let mut m_mappingType: _serde::__private::Option<MappingType> = _serde::__private::None;
276 for i in 0..8usize {
277 match i {
278 0usize => {
279 if _serde::__private::Option::is_some(&m_skeletonA) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field(
282 "skeletonA",
283 ),
284 );
285 }
286 m_skeletonA = _serde::__private::Some(
287 match __A::next_value::<Pointer>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 1usize => {
296 if _serde::__private::Option::is_some(&m_skeletonB) {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "skeletonB",
300 ),
301 );
302 }
303 m_skeletonB = _serde::__private::Some(
304 match __A::next_value::<Pointer>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 2usize => {
313 if _serde::__private::Option::is_some(&m_simpleMappings) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field(
316 "simpleMappings",
317 ),
318 );
319 }
320 m_simpleMappings = _serde::__private::Some(
321 match __A::next_value::<
322 Vec<hkaSkeletonMapperDataSimpleMapping>,
323 >(&mut __map) {
324 _serde::__private::Ok(__val) => __val,
325 _serde::__private::Err(__err) => {
326 return _serde::__private::Err(__err);
327 }
328 },
329 );
330 }
331 3usize => {
332 if _serde::__private::Option::is_some(&m_chainMappings) {
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::duplicate_field(
335 "chainMappings",
336 ),
337 );
338 }
339 m_chainMappings = _serde::__private::Some(
340 match __A::next_value::<
341 Vec<hkaSkeletonMapperDataChainMapping>,
342 >(&mut __map) {
343 _serde::__private::Ok(__val) => __val,
344 _serde::__private::Err(__err) => {
345 return _serde::__private::Err(__err);
346 }
347 },
348 );
349 }
350 4usize => {
351 if _serde::__private::Option::is_some(&m_unmappedBones) {
352 return _serde::__private::Err(
353 <__A::Error as _serde::de::Error>::duplicate_field(
354 "unmappedBones",
355 ),
356 );
357 }
358 m_unmappedBones = _serde::__private::Some(
359 match __A::next_value::<Vec<i16>>(&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(
369 &m_extractedMotionMapping,
370 ) {
371 return _serde::__private::Err(
372 <__A::Error as _serde::de::Error>::duplicate_field(
373 "extractedMotionMapping",
374 ),
375 );
376 }
377 __A::pad(&mut __map, 4usize, 0usize)?;
378 m_extractedMotionMapping = _serde::__private::Some(
379 match __A::next_value::<QsTransform>(&mut __map) {
380 _serde::__private::Ok(__val) => __val,
381 _serde::__private::Err(__err) => {
382 return _serde::__private::Err(__err);
383 }
384 },
385 );
386 }
387 6usize => {
388 if _serde::__private::Option::is_some(
389 &m_keepUnmappedLocal,
390 ) {
391 return _serde::__private::Err(
392 <__A::Error as _serde::de::Error>::duplicate_field(
393 "keepUnmappedLocal",
394 ),
395 );
396 }
397 m_keepUnmappedLocal = _serde::__private::Some(
398 match __A::next_value::<bool>(&mut __map) {
399 _serde::__private::Ok(__val) => __val,
400 _serde::__private::Err(__err) => {
401 return _serde::__private::Err(__err);
402 }
403 },
404 );
405 }
406 7usize => {
407 if _serde::__private::Option::is_some(&m_mappingType) {
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::duplicate_field(
410 "mappingType",
411 ),
412 );
413 }
414 __A::pad(&mut __map, 3usize, 3usize)?;
415 m_mappingType = _serde::__private::Some(
416 match __A::next_value::<MappingType>(&mut __map) {
417 _serde::__private::Ok(__val) => __val,
418 _serde::__private::Err(__err) => {
419 return _serde::__private::Err(__err);
420 }
421 },
422 );
423 }
424 _ => {}
425 }
426 }
427 __A::pad(&mut __map, 8usize, 8usize)?;
428 let m_skeletonA = match m_skeletonA {
429 _serde::__private::Some(__field) => __field,
430 _serde::__private::None => {
431 return _serde::__private::Err(
432 <__A::Error as _serde::de::Error>::missing_field(
433 "skeletonA",
434 ),
435 );
436 }
437 };
438 let m_skeletonB = match m_skeletonB {
439 _serde::__private::Some(__field) => __field,
440 _serde::__private::None => {
441 return _serde::__private::Err(
442 <__A::Error as _serde::de::Error>::missing_field(
443 "skeletonB",
444 ),
445 );
446 }
447 };
448 let m_simpleMappings = match m_simpleMappings {
449 _serde::__private::Some(__field) => __field,
450 _serde::__private::None => {
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::missing_field(
453 "simpleMappings",
454 ),
455 );
456 }
457 };
458 let m_chainMappings = match m_chainMappings {
459 _serde::__private::Some(__field) => __field,
460 _serde::__private::None => {
461 return _serde::__private::Err(
462 <__A::Error as _serde::de::Error>::missing_field(
463 "chainMappings",
464 ),
465 );
466 }
467 };
468 let m_unmappedBones = match m_unmappedBones {
469 _serde::__private::Some(__field) => __field,
470 _serde::__private::None => {
471 return _serde::__private::Err(
472 <__A::Error as _serde::de::Error>::missing_field(
473 "unmappedBones",
474 ),
475 );
476 }
477 };
478 let m_extractedMotionMapping = match m_extractedMotionMapping {
479 _serde::__private::Some(__field) => __field,
480 _serde::__private::None => {
481 return _serde::__private::Err(
482 <__A::Error as _serde::de::Error>::missing_field(
483 "extractedMotionMapping",
484 ),
485 );
486 }
487 };
488 let m_keepUnmappedLocal = match m_keepUnmappedLocal {
489 _serde::__private::Some(__field) => __field,
490 _serde::__private::None => {
491 return _serde::__private::Err(
492 <__A::Error as _serde::de::Error>::missing_field(
493 "keepUnmappedLocal",
494 ),
495 );
496 }
497 };
498 let m_mappingType = match m_mappingType {
499 _serde::__private::Some(__field) => __field,
500 _serde::__private::None => {
501 return _serde::__private::Err(
502 <__A::Error as _serde::de::Error>::missing_field(
503 "mappingType",
504 ),
505 );
506 }
507 };
508 _serde::__private::Ok(hkaSkeletonMapperData {
509 __ptr,
510 m_skeletonA,
511 m_skeletonB,
512 m_simpleMappings,
513 m_chainMappings,
514 m_unmappedBones,
515 m_extractedMotionMapping,
516 m_keepUnmappedLocal,
517 m_mappingType,
518 })
519 }
520 #[allow(clippy::manual_unwrap_or_default)]
521 fn visit_struct<__A>(
522 self,
523 mut __map: __A,
524 ) -> _serde::__private::Result<Self::Value, __A::Error>
525 where
526 __A: _serde::de::MapAccess<'de>,
527 {
528 let mut m_skeletonA: _serde::__private::Option<Pointer> = _serde::__private::None;
529 let mut m_skeletonB: _serde::__private::Option<Pointer> = _serde::__private::None;
530 let mut m_simpleMappings: _serde::__private::Option<
531 Vec<hkaSkeletonMapperDataSimpleMapping>,
532 > = _serde::__private::None;
533 let mut m_chainMappings: _serde::__private::Option<
534 Vec<hkaSkeletonMapperDataChainMapping>,
535 > = _serde::__private::None;
536 let mut m_unmappedBones: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
537 let mut m_extractedMotionMapping: _serde::__private::Option<
538 QsTransform,
539 > = _serde::__private::None;
540 let mut m_keepUnmappedLocal: _serde::__private::Option<bool> = _serde::__private::None;
541 let mut m_mappingType: _serde::__private::Option<MappingType> = _serde::__private::None;
542 while let _serde::__private::Some(__key) = {
543 __A::next_key::<__Field>(&mut __map)?
544 } {
545 match __key {
546 __Field::m_skeletonA => {
547 #[cfg(
548 any(feature = "strict", feature = "ignore_duplicates")
549 )]
550 if _serde::__private::Option::is_some(&m_skeletonA) {
551 #[cfg(feature = "ignore_duplicates")]
552 {
553 __A::skip_value(&mut __map)?;
554 continue;
555 }
556 #[cfg(feature = "strict")]
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::duplicate_field(
559 "skeletonA",
560 ),
561 );
562 }
563 m_skeletonA = _serde::__private::Some(
564 match __A::next_value::<Pointer>(&mut __map) {
565 _serde::__private::Ok(__val) => __val,
566 _serde::__private::Err(__err) => {
567 return _serde::__private::Err(__err);
568 }
569 },
570 );
571 }
572 __Field::m_skeletonB => {
573 #[cfg(
574 any(feature = "strict", feature = "ignore_duplicates")
575 )]
576 if _serde::__private::Option::is_some(&m_skeletonB) {
577 #[cfg(feature = "ignore_duplicates")]
578 {
579 __A::skip_value(&mut __map)?;
580 continue;
581 }
582 #[cfg(feature = "strict")]
583 return _serde::__private::Err(
584 <__A::Error as _serde::de::Error>::duplicate_field(
585 "skeletonB",
586 ),
587 );
588 }
589 m_skeletonB = _serde::__private::Some(
590 match __A::next_value::<Pointer>(&mut __map) {
591 _serde::__private::Ok(__val) => __val,
592 _serde::__private::Err(__err) => {
593 return _serde::__private::Err(__err);
594 }
595 },
596 );
597 }
598 __Field::m_simpleMappings => {
599 #[cfg(
600 any(feature = "strict", feature = "ignore_duplicates")
601 )]
602 if _serde::__private::Option::is_some(&m_simpleMappings) {
603 #[cfg(feature = "ignore_duplicates")]
604 {
605 __A::skip_value(&mut __map)?;
606 continue;
607 }
608 #[cfg(feature = "strict")]
609 return _serde::__private::Err(
610 <__A::Error as _serde::de::Error>::duplicate_field(
611 "simpleMappings",
612 ),
613 );
614 }
615 m_simpleMappings = _serde::__private::Some(
616 match __A::next_value::<
617 Vec<hkaSkeletonMapperDataSimpleMapping>,
618 >(&mut __map) {
619 _serde::__private::Ok(__val) => __val,
620 _serde::__private::Err(__err) => {
621 return _serde::__private::Err(__err);
622 }
623 },
624 );
625 }
626 __Field::m_chainMappings => {
627 #[cfg(
628 any(feature = "strict", feature = "ignore_duplicates")
629 )]
630 if _serde::__private::Option::is_some(&m_chainMappings) {
631 #[cfg(feature = "ignore_duplicates")]
632 {
633 __A::skip_value(&mut __map)?;
634 continue;
635 }
636 #[cfg(feature = "strict")]
637 return _serde::__private::Err(
638 <__A::Error as _serde::de::Error>::duplicate_field(
639 "chainMappings",
640 ),
641 );
642 }
643 m_chainMappings = _serde::__private::Some(
644 match __A::next_value::<
645 Vec<hkaSkeletonMapperDataChainMapping>,
646 >(&mut __map) {
647 _serde::__private::Ok(__val) => __val,
648 _serde::__private::Err(__err) => {
649 return _serde::__private::Err(__err);
650 }
651 },
652 );
653 }
654 __Field::m_unmappedBones => {
655 #[cfg(
656 any(feature = "strict", feature = "ignore_duplicates")
657 )]
658 if _serde::__private::Option::is_some(&m_unmappedBones) {
659 #[cfg(feature = "ignore_duplicates")]
660 {
661 __A::skip_value(&mut __map)?;
662 continue;
663 }
664 #[cfg(feature = "strict")]
665 return _serde::__private::Err(
666 <__A::Error as _serde::de::Error>::duplicate_field(
667 "unmappedBones",
668 ),
669 );
670 }
671 m_unmappedBones = _serde::__private::Some(
672 match __A::next_value::<Vec<i16>>(&mut __map) {
673 _serde::__private::Ok(__val) => __val,
674 _serde::__private::Err(__err) => {
675 return _serde::__private::Err(__err);
676 }
677 },
678 );
679 }
680 __Field::m_extractedMotionMapping => {
681 #[cfg(
682 any(feature = "strict", feature = "ignore_duplicates")
683 )]
684 if _serde::__private::Option::is_some(
685 &m_extractedMotionMapping,
686 ) {
687 #[cfg(feature = "ignore_duplicates")]
688 {
689 __A::skip_value(&mut __map)?;
690 continue;
691 }
692 #[cfg(feature = "strict")]
693 return _serde::__private::Err(
694 <__A::Error as _serde::de::Error>::duplicate_field(
695 "extractedMotionMapping",
696 ),
697 );
698 }
699 m_extractedMotionMapping = _serde::__private::Some(
700 match __A::next_value::<QsTransform>(&mut __map) {
701 _serde::__private::Ok(__val) => __val,
702 _serde::__private::Err(__err) => {
703 return _serde::__private::Err(__err);
704 }
705 },
706 );
707 }
708 __Field::m_keepUnmappedLocal => {
709 #[cfg(
710 any(feature = "strict", feature = "ignore_duplicates")
711 )]
712 if _serde::__private::Option::is_some(
713 &m_keepUnmappedLocal,
714 ) {
715 #[cfg(feature = "ignore_duplicates")]
716 {
717 __A::skip_value(&mut __map)?;
718 continue;
719 }
720 #[cfg(feature = "strict")]
721 return _serde::__private::Err(
722 <__A::Error as _serde::de::Error>::duplicate_field(
723 "keepUnmappedLocal",
724 ),
725 );
726 }
727 m_keepUnmappedLocal = _serde::__private::Some(
728 match __A::next_value::<bool>(&mut __map) {
729 _serde::__private::Ok(__val) => __val,
730 _serde::__private::Err(__err) => {
731 return _serde::__private::Err(__err);
732 }
733 },
734 );
735 }
736 __Field::m_mappingType => {
737 #[cfg(
738 any(feature = "strict", feature = "ignore_duplicates")
739 )]
740 if _serde::__private::Option::is_some(&m_mappingType) {
741 #[cfg(feature = "ignore_duplicates")]
742 {
743 __A::skip_value(&mut __map)?;
744 continue;
745 }
746 #[cfg(feature = "strict")]
747 return _serde::__private::Err(
748 <__A::Error as _serde::de::Error>::duplicate_field(
749 "mappingType",
750 ),
751 );
752 }
753 m_mappingType = _serde::__private::Some(
754 match __A::next_value::<MappingType>(&mut __map) {
755 _serde::__private::Ok(__val) => __val,
756 _serde::__private::Err(__err) => {
757 return _serde::__private::Err(__err);
758 }
759 },
760 );
761 }
762 _ => __A::skip_value(&mut __map)?,
763 }
764 }
765 let m_skeletonA = match m_skeletonA {
766 _serde::__private::Some(__field) => __field,
767 _serde::__private::None => {
768 #[cfg(feature = "strict")]
769 return _serde::__private::Err(
770 <__A::Error as _serde::de::Error>::missing_field(
771 "skeletonA",
772 ),
773 );
774 #[cfg(not(feature = "strict"))] Default::default()
775 }
776 };
777 let m_skeletonB = match m_skeletonB {
778 _serde::__private::Some(__field) => __field,
779 _serde::__private::None => {
780 #[cfg(feature = "strict")]
781 return _serde::__private::Err(
782 <__A::Error as _serde::de::Error>::missing_field(
783 "skeletonB",
784 ),
785 );
786 #[cfg(not(feature = "strict"))] Default::default()
787 }
788 };
789 let m_simpleMappings = match m_simpleMappings {
790 _serde::__private::Some(__field) => __field,
791 _serde::__private::None => {
792 #[cfg(feature = "strict")]
793 return _serde::__private::Err(
794 <__A::Error as _serde::de::Error>::missing_field(
795 "simpleMappings",
796 ),
797 );
798 #[cfg(not(feature = "strict"))] Default::default()
799 }
800 };
801 let m_chainMappings = match m_chainMappings {
802 _serde::__private::Some(__field) => __field,
803 _serde::__private::None => {
804 #[cfg(feature = "strict")]
805 return _serde::__private::Err(
806 <__A::Error as _serde::de::Error>::missing_field(
807 "chainMappings",
808 ),
809 );
810 #[cfg(not(feature = "strict"))] Default::default()
811 }
812 };
813 let m_unmappedBones = match m_unmappedBones {
814 _serde::__private::Some(__field) => __field,
815 _serde::__private::None => {
816 #[cfg(feature = "strict")]
817 return _serde::__private::Err(
818 <__A::Error as _serde::de::Error>::missing_field(
819 "unmappedBones",
820 ),
821 );
822 #[cfg(not(feature = "strict"))] Default::default()
823 }
824 };
825 let m_extractedMotionMapping = match m_extractedMotionMapping {
826 _serde::__private::Some(__field) => __field,
827 _serde::__private::None => {
828 #[cfg(feature = "strict")]
829 return _serde::__private::Err(
830 <__A::Error as _serde::de::Error>::missing_field(
831 "extractedMotionMapping",
832 ),
833 );
834 #[cfg(not(feature = "strict"))] Default::default()
835 }
836 };
837 let m_keepUnmappedLocal = match m_keepUnmappedLocal {
838 _serde::__private::Some(__field) => __field,
839 _serde::__private::None => {
840 #[cfg(feature = "strict")]
841 return _serde::__private::Err(
842 <__A::Error as _serde::de::Error>::missing_field(
843 "keepUnmappedLocal",
844 ),
845 );
846 #[cfg(not(feature = "strict"))] Default::default()
847 }
848 };
849 let m_mappingType = match m_mappingType {
850 _serde::__private::Some(__field) => __field,
851 _serde::__private::None => {
852 #[cfg(feature = "strict")]
853 return _serde::__private::Err(
854 <__A::Error as _serde::de::Error>::missing_field(
855 "mappingType",
856 ),
857 );
858 #[cfg(not(feature = "strict"))] Default::default()
859 }
860 };
861 let __ptr = __A::class_ptr(&mut __map);
862 _serde::__private::Ok(hkaSkeletonMapperData {
863 __ptr,
864 m_skeletonA,
865 m_skeletonB,
866 m_simpleMappings,
867 m_chainMappings,
868 m_unmappedBones,
869 m_extractedMotionMapping,
870 m_keepUnmappedLocal,
871 m_mappingType,
872 })
873 }
874 }
875 const FIELDS: &[&str] = &[
876 "skeletonA",
877 "skeletonB",
878 "simpleMappings",
879 "chainMappings",
880 "unmappedBones",
881 "extractedMotionMapping",
882 "keepUnmappedLocal",
883 "mappingType",
884 ];
885 _serde::Deserializer::deserialize_struct(
886 deserializer,
887 "hkaSkeletonMapperData",
888 FIELDS,
889 __hkaSkeletonMapperDataVisitor {
890 marker: _serde::__private::PhantomData::<hkaSkeletonMapperData>,
891 lifetime: _serde::__private::PhantomData,
892 },
893 )
894 }
895 }
896};
897#[allow(non_upper_case_globals, non_snake_case)]
900#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
901#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
902#[derive(
903 Debug,
904 Clone,
905 Default,
906 PartialEq,
907 Eq,
908 PartialOrd,
909 Ord,
910 num_derive::ToPrimitive,
911 num_derive::FromPrimitive,
912)]
913pub enum MappingType {
914 #[default]
915 HK_RAGDOLL_MAPPING = 0isize,
916 HK_RETARGETING_MAPPING = 1isize,
917}
918const _: () = {
919 use havok_serde as __serde;
920 impl __serde::Serialize for MappingType {
921 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
922 where
923 S: __serde::ser::Serializer,
924 {
925 let mut __serializer = __serializer.serialize_enum_flags()?;
926 match self {
927 Self::HK_RAGDOLL_MAPPING => {
928 __serializer.serialize_field("HK_RAGDOLL_MAPPING", &0u64)
929 }
930 Self::HK_RETARGETING_MAPPING => {
931 __serializer.serialize_field("HK_RETARGETING_MAPPING", &1u64)
932 }
933 }?;
934 use num_traits::ToPrimitive as _;
935 let num = self
936 .to_i32()
937 .ok_or(S::Error::custom("Failed enum MappingType to_i32"))?;
938 __serializer.serialize_bits(&num)?;
939 __serializer.end()
940 }
941 }
942};
943#[doc(hidden)]
944#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
945const _: () = {
946 #[allow(unused_extern_crates, clippy::useless_attribute)]
947 extern crate havok_serde as _serde;
948 #[automatically_derived]
949 impl<'de> _serde::Deserialize<'de> for MappingType {
950 fn deserialize<__D>(
951 __deserializer: __D,
952 ) -> _serde::__private::Result<Self, __D::Error>
953 where
954 __D: _serde::Deserializer<'de>,
955 {
956 #[allow(non_camel_case_types)]
957 #[doc(hidden)]
958 enum __Field {
959 __field0,
960 __field1,
961 }
962 #[doc(hidden)]
963 struct __FieldVisitor;
964 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
965 type Value = __Field;
966 fn expecting(
967 &self,
968 __formatter: &mut _serde::__private::Formatter,
969 ) -> _serde::__private::fmt::Result {
970 _serde::__private::Formatter::write_str(
971 __formatter,
972 "variant identifier",
973 )
974 }
975 fn visit_int32<__E>(
976 self,
977 __value: i32,
978 ) -> _serde::__private::Result<Self::Value, __E>
979 where
980 __E: _serde::de::Error,
981 {
982 match __value {
983 0i32 => _serde::__private::Ok(__Field::__field0),
984 1i32 => _serde::__private::Ok(__Field::__field1),
985 _ => {
986 _serde::__private::Err(
987 _serde::de::Error::invalid_value(
988 _serde::de::Unexpected::Int32(__value),
989 &"value(i32) of variant is one of 0, 1",
990 ),
991 )
992 }
993 }
994 }
995 fn visit_stringptr<__E>(
996 self,
997 __value: StringPtr<'de>,
998 ) -> _serde::__private::Result<Self::Value, __E>
999 where
1000 __E: _serde::de::Error,
1001 {
1002 if let Some(__value) = __value.into_inner() {
1003 match __value.as_ref() {
1004 v if v == "0"
1005 || v.eq_ignore_ascii_case("HK_RAGDOLL_MAPPING") => {
1006 _serde::__private::Ok(__Field::__field0)
1007 }
1008 v if v == "1"
1009 || v.eq_ignore_ascii_case("HK_RETARGETING_MAPPING") => {
1010 _serde::__private::Ok(__Field::__field1)
1011 }
1012 _ => {
1013 _serde::__private::Err(
1014 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1015 )
1016 }
1017 }
1018 } else {
1019 _serde::__private::Err(
1020 _serde::de::Error::unknown_variant("None", VARIANTS),
1021 )
1022 }
1023 }
1024 }
1025 impl<'de> _serde::Deserialize<'de> for __Field {
1026 #[inline]
1027 fn deserialize<__D>(
1028 __deserializer: __D,
1029 ) -> _serde::__private::Result<Self, __D::Error>
1030 where
1031 __D: _serde::Deserializer<'de>,
1032 {
1033 _serde::Deserializer::deserialize_identifier(
1034 __deserializer,
1035 _serde::de::ReadEnumSize::Int32,
1036 __FieldVisitor,
1037 )
1038 }
1039 }
1040 #[doc(hidden)]
1041 struct __Visitor<'de> {
1042 marker: _serde::__private::PhantomData<MappingType>,
1043 lifetime: _serde::__private::PhantomData<&'de ()>,
1044 }
1045 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1046 type Value = MappingType;
1047 fn expecting(
1048 &self,
1049 __formatter: &mut _serde::__private::Formatter,
1050 ) -> _serde::__private::fmt::Result {
1051 _serde::__private::Formatter::write_str(
1052 __formatter,
1053 "enum MappingType",
1054 )
1055 }
1056 fn visit_enum<__A>(
1057 self,
1058 __data: __A,
1059 ) -> _serde::__private::Result<Self::Value, __A::Error>
1060 where
1061 __A: _serde::de::EnumAccess<'de>,
1062 {
1063 match _serde::de::EnumAccess::variant(__data)? {
1064 (__Field::__field0, __variant) => {
1065 _serde::de::VariantAccess::unit_variant(__variant)?;
1066 _serde::__private::Ok(MappingType::HK_RAGDOLL_MAPPING)
1067 }
1068 (__Field::__field1, __variant) => {
1069 _serde::de::VariantAccess::unit_variant(__variant)?;
1070 _serde::__private::Ok(MappingType::HK_RETARGETING_MAPPING)
1071 }
1072 }
1073 }
1074 }
1075 #[doc(hidden)]
1076 const VARIANTS: &'static [&'static str] = &[
1077 "HK_RAGDOLL_MAPPING",
1078 "HK_RETARGETING_MAPPING",
1079 ];
1080 _serde::Deserializer::deserialize_enum(
1081 __deserializer,
1082 "MappingType",
1083 VARIANTS,
1084 __Visitor {
1085 marker: _serde::__private::PhantomData::<MappingType>,
1086 lifetime: _serde::__private::PhantomData,
1087 },
1088 )
1089 }
1090 }
1091};