havok_classes/generated/
hkxAttribute_.rs

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

havok_classes/generated/
hkxAttribute_.rs
