havok_classes/generated/
hkbTwistModifier_.rs

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