havok_classes/generated/
hkaSkeletonMapperData_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkaSkeletonMapperData`
5/// - version: `1`
6/// - signature: `0x95687ea0`
7/// - size: `112`(x86)/`128`(x86_64)
8/// -  vtable: `false`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// # C++ Info
27    /// - name: `skeletonA`(ctype: `struct hkaSkeleton*`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  4`(x86)/`  8`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "skeletonA"))]
31    #[cfg_attr(feature = "serde", serde(rename = "skeletonA"))]
32    pub m_skeletonA: Pointer,
33    /// # C++ Info
34    /// - name: `skeletonB`(ctype: `struct hkaSkeleton*`)
35    /// - offset: `  4`(x86)/`  8`(x86_64)
36    /// - type_size: `  4`(x86)/`  8`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "skeletonB"))]
38    #[cfg_attr(feature = "serde", serde(rename = "skeletonB"))]
39    pub m_skeletonB: Pointer,
40    /// # C++ Info
41    /// - name: `simpleMappings`(ctype: `hkArray<struct hkaSkeletonMapperDataSimpleMapping>`)
42    /// - offset: `  8`(x86)/` 16`(x86_64)
43    /// - type_size: ` 12`(x86)/` 16`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "simpleMappings"))]
45    #[cfg_attr(feature = "serde", serde(rename = "simpleMappings"))]
46    pub m_simpleMappings: Vec<hkaSkeletonMapperDataSimpleMapping>,
47    /// # C++ Info
48    /// - name: `chainMappings`(ctype: `hkArray<struct hkaSkeletonMapperDataChainMapping>`)
49    /// - offset: ` 20`(x86)/` 32`(x86_64)
50    /// - type_size: ` 12`(x86)/` 16`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "chainMappings"))]
52    #[cfg_attr(feature = "serde", serde(rename = "chainMappings"))]
53    pub m_chainMappings: Vec<hkaSkeletonMapperDataChainMapping>,
54    /// # C++ Info
55    /// - name: `unmappedBones`(ctype: `hkArray<hkInt16>`)
56    /// - offset: ` 32`(x86)/` 48`(x86_64)
57    /// - type_size: ` 12`(x86)/` 16`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "unmappedBones"))]
59    #[cfg_attr(feature = "serde", serde(rename = "unmappedBones"))]
60    pub m_unmappedBones: Vec<i16>,
61    /// # C++ Info
62    /// - name: `extractedMotionMapping`(ctype: `hkQsTransform`)
63    /// - offset: ` 48`(x86)/` 64`(x86_64)
64    /// - type_size: ` 48`(x86)/` 48`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "extractedMotionMapping"))]
66    #[cfg_attr(feature = "serde", serde(rename = "extractedMotionMapping"))]
67    pub m_extractedMotionMapping: QsTransform,
68    /// # C++ Info
69    /// - name: `keepUnmappedLocal`(ctype: `hkBool`)
70    /// - offset: ` 96`(x86)/`112`(x86_64)
71    /// - type_size: `  1`(x86)/`  1`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "keepUnmappedLocal"))]
73    #[cfg_attr(feature = "serde", serde(rename = "keepUnmappedLocal"))]
74    pub m_keepUnmappedLocal: bool,
75    /// # C++ Info
76    /// - name: `mappingType`(ctype: `enum MappingType`)
77    /// - offset: `100`(x86)/`116`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[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                /// Intended for use in XML.
202                #[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/// # C++ Info
898/// - name: `MappingType`(ctype: `hkEnum<MappingType, hkInt32>`)
899#[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};