havok_classes/generated/
hkGizmoAttribute_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkGizmoAttribute`
5/// - version: `0`
6/// - signature: `0x23aadfb6`
7/// - size: ` 12`(x86)/` 24`(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 hkGizmoAttribute<'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: `label`(ctype: `char*`)
35    /// - offset: `  4`(x86)/`  8`(x86_64)
36    /// - type_size: `  4`(x86)/`  8`(x86_64)
37    #[cfg_attr(feature = "serde", serde(borrow))]
38    #[cfg_attr(feature = "json_schema", schemars(rename = "label"))]
39    #[cfg_attr(feature = "serde", serde(rename = "label"))]
40    pub m_label: CString<'a>,
41    /// # C++ Info
42    /// - name: `type`(ctype: `enum GizmoType`)
43    /// - offset: `  8`(x86)/` 16`(x86_64)
44    /// - type_size: `  1`(x86)/`  1`(x86_64)
45    #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
46    #[cfg_attr(feature = "serde", serde(rename = "type"))]
47    pub m_type: GizmoType,
48}
49const _: () = {
50    use havok_serde as _serde;
51    impl<'a> _serde::HavokClass for hkGizmoAttribute<'a> {
52        #[inline]
53        fn name(&self) -> &'static str {
54            "hkGizmoAttribute"
55        }
56        #[inline]
57        fn signature(&self) -> _serde::__private::Signature {
58            _serde::__private::Signature::new(0x23aadfb6)
59        }
60        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
61        fn deps_indexes(&self) -> Vec<usize> {
62            let mut v = Vec::new();
63            v
64        }
65    }
66    impl<'a> _serde::Serialize for hkGizmoAttribute<'a> {
67        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
68        where
69            S: _serde::ser::Serializer,
70        {
71            let class_meta = self
72                .__ptr
73                .map(|name| (name, _serde::__private::Signature::new(0x23aadfb6)));
74            let mut serializer = __serializer
75                .serialize_struct("hkGizmoAttribute", class_meta, (12u64, 24u64))?;
76            serializer.serialize_field("visible", &self.m_visible)?;
77            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
78            serializer.serialize_field("label", &self.m_label)?;
79            serializer.serialize_field("type", &self.m_type)?;
80            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
81            serializer.end()
82        }
83    }
84};
85#[doc(hidden)]
86#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
87const _: () = {
88    use havok_serde as _serde;
89    #[automatically_derived]
90    impl<'de> _serde::Deserialize<'de> for hkGizmoAttribute<'de> {
91        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
92        where
93            __D: _serde::Deserializer<'de>,
94        {
95            #[allow(non_camel_case_types)]
96            enum __Field {
97                m_visible,
98                m_label,
99                m_type,
100                __ignore,
101            }
102            struct __FieldVisitor;
103            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
104                type Value = __Field;
105                fn expecting(
106                    &self,
107                    __formatter: &mut core::fmt::Formatter,
108                ) -> core::fmt::Result {
109                    core::fmt::Formatter::write_str(__formatter, "field identifier")
110                }
111                /// Intended for use in XML.
112                #[allow(clippy::match_single_binding)]
113                #[allow(clippy::reversed_empty_ranges)]
114                #[allow(clippy::single_match)]
115                fn visit_key<__E>(
116                    self,
117                    __value: &str,
118                ) -> core::result::Result<Self::Value, __E>
119                where
120                    __E: _serde::de::Error,
121                {
122                    match __value {
123                        "visible" => Ok(__Field::m_visible),
124                        "label" => Ok(__Field::m_label),
125                        "type" => Ok(__Field::m_type),
126                        _ => Ok(__Field::__ignore),
127                    }
128                }
129            }
130            impl<'de> _serde::Deserialize<'de> for __Field {
131                #[inline]
132                fn deserialize<__D>(
133                    __deserializer: __D,
134                ) -> core::result::Result<Self, __D::Error>
135                where
136                    __D: _serde::Deserializer<'de>,
137                {
138                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
139                }
140            }
141            struct __hkGizmoAttributeVisitor<'de> {
142                marker: _serde::__private::PhantomData<hkGizmoAttribute<'de>>,
143                lifetime: _serde::__private::PhantomData<&'de ()>,
144            }
145            #[allow(clippy::match_single_binding)]
146            #[allow(clippy::reversed_empty_ranges)]
147            #[allow(clippy::single_match)]
148            impl<'de> _serde::de::Visitor<'de> for __hkGizmoAttributeVisitor<'de> {
149                type Value = hkGizmoAttribute<'de>;
150                fn expecting(
151                    &self,
152                    __formatter: &mut core::fmt::Formatter,
153                ) -> core::fmt::Result {
154                    core::fmt::Formatter::write_str(
155                        __formatter,
156                        "struct hkGizmoAttribute",
157                    )
158                }
159                fn visit_struct_for_bytes<__A>(
160                    self,
161                    mut __map: __A,
162                ) -> _serde::__private::Result<Self::Value, __A::Error>
163                where
164                    __A: _serde::de::MapAccess<'de>,
165                {
166                    let __ptr = __A::class_ptr(&mut __map);
167                    let mut m_visible: _serde::__private::Option<bool> = _serde::__private::None;
168                    let mut m_label: _serde::__private::Option<CString<'de>> = _serde::__private::None;
169                    let mut m_type: _serde::__private::Option<GizmoType> = _serde::__private::None;
170                    for i in 0..3usize {
171                        match i {
172                            0usize => {
173                                if _serde::__private::Option::is_some(&m_visible) {
174                                    return _serde::__private::Err(
175                                        <__A::Error as _serde::de::Error>::duplicate_field(
176                                            "visible",
177                                        ),
178                                    );
179                                }
180                                m_visible = _serde::__private::Some(
181                                    match __A::next_value::<bool>(&mut __map) {
182                                        _serde::__private::Ok(__val) => __val,
183                                        _serde::__private::Err(__err) => {
184                                            return _serde::__private::Err(__err);
185                                        }
186                                    },
187                                );
188                            }
189                            1usize => {
190                                if _serde::__private::Option::is_some(&m_label) {
191                                    return _serde::__private::Err(
192                                        <__A::Error as _serde::de::Error>::duplicate_field("label"),
193                                    );
194                                }
195                                __A::pad(&mut __map, 3usize, 7usize)?;
196                                m_label = _serde::__private::Some(
197                                    match __A::next_value::<CString<'de>>(&mut __map) {
198                                        _serde::__private::Ok(__val) => __val,
199                                        _serde::__private::Err(__err) => {
200                                            return _serde::__private::Err(__err);
201                                        }
202                                    },
203                                );
204                            }
205                            2usize => {
206                                if _serde::__private::Option::is_some(&m_type) {
207                                    return _serde::__private::Err(
208                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
209                                    );
210                                }
211                                m_type = _serde::__private::Some(
212                                    match __A::next_value::<GizmoType>(&mut __map) {
213                                        _serde::__private::Ok(__val) => __val,
214                                        _serde::__private::Err(__err) => {
215                                            return _serde::__private::Err(__err);
216                                        }
217                                    },
218                                );
219                            }
220                            _ => {}
221                        }
222                    }
223                    __A::pad(&mut __map, 3usize, 7usize)?;
224                    let m_visible = match m_visible {
225                        _serde::__private::Some(__field) => __field,
226                        _serde::__private::None => {
227                            return _serde::__private::Err(
228                                <__A::Error as _serde::de::Error>::missing_field("visible"),
229                            );
230                        }
231                    };
232                    let m_label = match m_label {
233                        _serde::__private::Some(__field) => __field,
234                        _serde::__private::None => {
235                            return _serde::__private::Err(
236                                <__A::Error as _serde::de::Error>::missing_field("label"),
237                            );
238                        }
239                    };
240                    let m_type = match m_type {
241                        _serde::__private::Some(__field) => __field,
242                        _serde::__private::None => {
243                            return _serde::__private::Err(
244                                <__A::Error as _serde::de::Error>::missing_field("type"),
245                            );
246                        }
247                    };
248                    _serde::__private::Ok(hkGizmoAttribute {
249                        __ptr,
250                        m_visible,
251                        m_label,
252                        m_type,
253                    })
254                }
255                #[allow(clippy::manual_unwrap_or_default)]
256                fn visit_struct<__A>(
257                    self,
258                    mut __map: __A,
259                ) -> _serde::__private::Result<Self::Value, __A::Error>
260                where
261                    __A: _serde::de::MapAccess<'de>,
262                {
263                    let mut m_visible: _serde::__private::Option<bool> = _serde::__private::None;
264                    let mut m_label: _serde::__private::Option<CString<'de>> = _serde::__private::None;
265                    let mut m_type: _serde::__private::Option<GizmoType> = _serde::__private::None;
266                    while let _serde::__private::Some(__key) = {
267                        __A::next_key::<__Field>(&mut __map)?
268                    } {
269                        match __key {
270                            __Field::m_visible => {
271                                #[cfg(
272                                    any(feature = "strict", feature = "ignore_duplicates")
273                                )]
274                                if _serde::__private::Option::is_some(&m_visible) {
275                                    #[cfg(feature = "ignore_duplicates")]
276                                    {
277                                        __A::skip_value(&mut __map)?;
278                                        continue;
279                                    }
280                                    #[cfg(feature = "strict")]
281                                    return _serde::__private::Err(
282                                        <__A::Error as _serde::de::Error>::duplicate_field(
283                                            "visible",
284                                        ),
285                                    );
286                                }
287                                m_visible = _serde::__private::Some(
288                                    match __A::next_value::<bool>(&mut __map) {
289                                        _serde::__private::Ok(__val) => __val,
290                                        _serde::__private::Err(__err) => {
291                                            return _serde::__private::Err(__err);
292                                        }
293                                    },
294                                );
295                            }
296                            __Field::m_label => {
297                                #[cfg(
298                                    any(feature = "strict", feature = "ignore_duplicates")
299                                )]
300                                if _serde::__private::Option::is_some(&m_label) {
301                                    #[cfg(feature = "ignore_duplicates")]
302                                    {
303                                        __A::skip_value(&mut __map)?;
304                                        continue;
305                                    }
306                                    #[cfg(feature = "strict")]
307                                    return _serde::__private::Err(
308                                        <__A::Error as _serde::de::Error>::duplicate_field("label"),
309                                    );
310                                }
311                                m_label = _serde::__private::Some(
312                                    match __A::next_value::<CString<'de>>(&mut __map) {
313                                        _serde::__private::Ok(__val) => __val,
314                                        _serde::__private::Err(__err) => {
315                                            return _serde::__private::Err(__err);
316                                        }
317                                    },
318                                );
319                            }
320                            __Field::m_type => {
321                                #[cfg(
322                                    any(feature = "strict", feature = "ignore_duplicates")
323                                )]
324                                if _serde::__private::Option::is_some(&m_type) {
325                                    #[cfg(feature = "ignore_duplicates")]
326                                    {
327                                        __A::skip_value(&mut __map)?;
328                                        continue;
329                                    }
330                                    #[cfg(feature = "strict")]
331                                    return _serde::__private::Err(
332                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
333                                    );
334                                }
335                                m_type = _serde::__private::Some(
336                                    match __A::next_value::<GizmoType>(&mut __map) {
337                                        _serde::__private::Ok(__val) => __val,
338                                        _serde::__private::Err(__err) => {
339                                            return _serde::__private::Err(__err);
340                                        }
341                                    },
342                                );
343                            }
344                            _ => __A::skip_value(&mut __map)?,
345                        }
346                    }
347                    let m_visible = match m_visible {
348                        _serde::__private::Some(__field) => __field,
349                        _serde::__private::None => {
350                            #[cfg(feature = "strict")]
351                            return _serde::__private::Err(
352                                <__A::Error as _serde::de::Error>::missing_field("visible"),
353                            );
354                            #[cfg(not(feature = "strict"))] Default::default()
355                        }
356                    };
357                    let m_label = match m_label {
358                        _serde::__private::Some(__field) => __field,
359                        _serde::__private::None => {
360                            #[cfg(feature = "strict")]
361                            return _serde::__private::Err(
362                                <__A::Error as _serde::de::Error>::missing_field("label"),
363                            );
364                            #[cfg(not(feature = "strict"))] Default::default()
365                        }
366                    };
367                    let m_type = match m_type {
368                        _serde::__private::Some(__field) => __field,
369                        _serde::__private::None => {
370                            #[cfg(feature = "strict")]
371                            return _serde::__private::Err(
372                                <__A::Error as _serde::de::Error>::missing_field("type"),
373                            );
374                            #[cfg(not(feature = "strict"))] Default::default()
375                        }
376                    };
377                    let __ptr = __A::class_ptr(&mut __map);
378                    _serde::__private::Ok(hkGizmoAttribute {
379                        __ptr,
380                        m_visible,
381                        m_label,
382                        m_type,
383                    })
384                }
385            }
386            const FIELDS: &[&str] = &["visible", "label", "type"];
387            _serde::Deserializer::deserialize_struct(
388                deserializer,
389                "hkGizmoAttribute",
390                FIELDS,
391                __hkGizmoAttributeVisitor {
392                    marker: _serde::__private::PhantomData::<hkGizmoAttribute>,
393                    lifetime: _serde::__private::PhantomData,
394                },
395            )
396        }
397    }
398};
399/// # C++ Info
400/// - name: `GizmoType`(ctype: `hkEnum<GizmoType, hkInt8>`)
401#[allow(non_upper_case_globals, non_snake_case)]
402#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
403#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
404#[derive(
405    Debug,
406    Clone,
407    Default,
408    PartialEq,
409    Eq,
410    PartialOrd,
411    Ord,
412    num_derive::ToPrimitive,
413    num_derive::FromPrimitive,
414)]
415pub enum GizmoType {
416    #[default]
417    POINT = 0isize,
418    SPHERE = 1isize,
419    PLANE = 2isize,
420    ARROW = 3isize,
421}
422const _: () = {
423    use havok_serde as __serde;
424    impl __serde::Serialize for GizmoType {
425        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
426        where
427            S: __serde::ser::Serializer,
428        {
429            let mut __serializer = __serializer.serialize_enum_flags()?;
430            match self {
431                Self::POINT => __serializer.serialize_field("POINT", &0u64),
432                Self::SPHERE => __serializer.serialize_field("SPHERE", &1u64),
433                Self::PLANE => __serializer.serialize_field("PLANE", &2u64),
434                Self::ARROW => __serializer.serialize_field("ARROW", &3u64),
435            }?;
436            use num_traits::ToPrimitive as _;
437            let num = self
438                .to_i8()
439                .ok_or(S::Error::custom("Failed enum GizmoType to_i8"))?;
440            __serializer.serialize_bits(&num)?;
441            __serializer.end()
442        }
443    }
444};
445#[doc(hidden)]
446#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
447const _: () = {
448    #[allow(unused_extern_crates, clippy::useless_attribute)]
449    extern crate havok_serde as _serde;
450    #[automatically_derived]
451    impl<'de> _serde::Deserialize<'de> for GizmoType {
452        fn deserialize<__D>(
453            __deserializer: __D,
454        ) -> _serde::__private::Result<Self, __D::Error>
455        where
456            __D: _serde::Deserializer<'de>,
457        {
458            #[allow(non_camel_case_types)]
459            #[doc(hidden)]
460            enum __Field {
461                __field0,
462                __field1,
463                __field2,
464                __field3,
465            }
466            #[doc(hidden)]
467            struct __FieldVisitor;
468            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
469                type Value = __Field;
470                fn expecting(
471                    &self,
472                    __formatter: &mut _serde::__private::Formatter,
473                ) -> _serde::__private::fmt::Result {
474                    _serde::__private::Formatter::write_str(
475                        __formatter,
476                        "variant identifier",
477                    )
478                }
479                fn visit_int8<__E>(
480                    self,
481                    __value: i8,
482                ) -> _serde::__private::Result<Self::Value, __E>
483                where
484                    __E: _serde::de::Error,
485                {
486                    match __value {
487                        0i8 => _serde::__private::Ok(__Field::__field0),
488                        1i8 => _serde::__private::Ok(__Field::__field1),
489                        2i8 => _serde::__private::Ok(__Field::__field2),
490                        3i8 => _serde::__private::Ok(__Field::__field3),
491                        _ => {
492                            _serde::__private::Err(
493                                _serde::de::Error::invalid_value(
494                                    _serde::de::Unexpected::Int8(__value),
495                                    &"value(i8) of variant is one of 0, 1, 2, 3",
496                                ),
497                            )
498                        }
499                    }
500                }
501                fn visit_stringptr<__E>(
502                    self,
503                    __value: StringPtr<'de>,
504                ) -> _serde::__private::Result<Self::Value, __E>
505                where
506                    __E: _serde::de::Error,
507                {
508                    if let Some(__value) = __value.into_inner() {
509                        match __value.as_ref() {
510                            v if v == "0" || v.eq_ignore_ascii_case("POINT") => {
511                                _serde::__private::Ok(__Field::__field0)
512                            }
513                            v if v == "1" || v.eq_ignore_ascii_case("SPHERE") => {
514                                _serde::__private::Ok(__Field::__field1)
515                            }
516                            v if v == "2" || v.eq_ignore_ascii_case("PLANE") => {
517                                _serde::__private::Ok(__Field::__field2)
518                            }
519                            v if v == "3" || v.eq_ignore_ascii_case("ARROW") => {
520                                _serde::__private::Ok(__Field::__field3)
521                            }
522                            _ => {
523                                _serde::__private::Err(
524                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
525                                )
526                            }
527                        }
528                    } else {
529                        _serde::__private::Err(
530                            _serde::de::Error::unknown_variant("None", VARIANTS),
531                        )
532                    }
533                }
534            }
535            impl<'de> _serde::Deserialize<'de> for __Field {
536                #[inline]
537                fn deserialize<__D>(
538                    __deserializer: __D,
539                ) -> _serde::__private::Result<Self, __D::Error>
540                where
541                    __D: _serde::Deserializer<'de>,
542                {
543                    _serde::Deserializer::deserialize_identifier(
544                        __deserializer,
545                        _serde::de::ReadEnumSize::Int8,
546                        __FieldVisitor,
547                    )
548                }
549            }
550            #[doc(hidden)]
551            struct __Visitor<'de> {
552                marker: _serde::__private::PhantomData<GizmoType>,
553                lifetime: _serde::__private::PhantomData<&'de ()>,
554            }
555            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
556                type Value = GizmoType;
557                fn expecting(
558                    &self,
559                    __formatter: &mut _serde::__private::Formatter,
560                ) -> _serde::__private::fmt::Result {
561                    _serde::__private::Formatter::write_str(
562                        __formatter,
563                        "enum GizmoType",
564                    )
565                }
566                fn visit_enum<__A>(
567                    self,
568                    __data: __A,
569                ) -> _serde::__private::Result<Self::Value, __A::Error>
570                where
571                    __A: _serde::de::EnumAccess<'de>,
572                {
573                    match _serde::de::EnumAccess::variant(__data)? {
574                        (__Field::__field0, __variant) => {
575                            _serde::de::VariantAccess::unit_variant(__variant)?;
576                            _serde::__private::Ok(GizmoType::POINT)
577                        }
578                        (__Field::__field1, __variant) => {
579                            _serde::de::VariantAccess::unit_variant(__variant)?;
580                            _serde::__private::Ok(GizmoType::SPHERE)
581                        }
582                        (__Field::__field2, __variant) => {
583                            _serde::de::VariantAccess::unit_variant(__variant)?;
584                            _serde::__private::Ok(GizmoType::PLANE)
585                        }
586                        (__Field::__field3, __variant) => {
587                            _serde::de::VariantAccess::unit_variant(__variant)?;
588                            _serde::__private::Ok(GizmoType::ARROW)
589                        }
590                    }
591                }
592            }
593            #[doc(hidden)]
594            const VARIANTS: &'static [&'static str] = &[
595                "POINT",
596                "SPHERE",
597                "PLANE",
598                "ARROW",
599            ];
600            _serde::Deserializer::deserialize_enum(
601                __deserializer,
602                "GizmoType",
603                VARIANTS,
604                __Visitor {
605                    marker: _serde::__private::PhantomData::<GizmoType>,
606                    lifetime: _serde::__private::PhantomData,
607                },
608            )
609        }
610    }
611};
havok_classes/generated/hkGizmoAttribute_.rs

havok_classes/generated/
hkGizmoAttribute_.rs
