havok_classes/generated/
hkClassMember_.rs

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