havok_classes/generated/
hkpPointToPathConstraintData_.rs

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