havok_classes/generated/
hkpConeLimitConstraintAtom_.rs

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