havok_classes/generated/
hkpConstraintInstance_.rs

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

havok_classes/generated/
hkpConstraintInstance_.rs
