havok_classes/generated/
hkUiAttribute_.rs

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