havok_classes/generated/
hkxVertexDescription_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkxVertexDescription`
5/// - version: `1`
6/// - signature: `0x2df6313d`
7/// - size: ` 12`(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 hkxVertexDescription {
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: `decls`(ctype: `hkArray<struct hkxVertexDescriptionElementDecl>`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 12`(x86)/` 16`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "decls"))]
31    #[cfg_attr(feature = "serde", serde(rename = "decls"))]
32    pub m_decls: Vec<hkxVertexDescriptionElementDecl>,
33}
34const _: () = {
35    use havok_serde as _serde;
36    impl _serde::HavokClass for hkxVertexDescription {
37        #[inline]
38        fn name(&self) -> &'static str {
39            "hkxVertexDescription"
40        }
41        #[inline]
42        fn signature(&self) -> _serde::__private::Signature {
43            _serde::__private::Signature::new(0x2df6313d)
44        }
45        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
46        fn deps_indexes(&self) -> Vec<usize> {
47            let mut v = Vec::new();
48            v.extend(
49                self
50                    .m_decls
51                    .iter()
52                    .flat_map(|class| class.deps_indexes())
53                    .collect::<Vec<usize>>(),
54            );
55            v
56        }
57    }
58    impl _serde::Serialize for hkxVertexDescription {
59        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
60        where
61            S: _serde::ser::Serializer,
62        {
63            let class_meta = self
64                .__ptr
65                .map(|name| (name, _serde::__private::Signature::new(0x2df6313d)));
66            let mut serializer = __serializer
67                .serialize_struct("hkxVertexDescription", class_meta, (12u64, 16u64))?;
68            serializer
69                .serialize_array_field(
70                    "decls",
71                    &self.m_decls,
72                    TypeSize::Struct {
73                        size_x86: 16u64,
74                        size_x86_64: 16u64,
75                    },
76                )?;
77            serializer.end()
78        }
79    }
80};
81#[doc(hidden)]
82#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
83const _: () = {
84    use havok_serde as _serde;
85    #[automatically_derived]
86    impl<'de> _serde::Deserialize<'de> for hkxVertexDescription {
87        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
88        where
89            __D: _serde::Deserializer<'de>,
90        {
91            #[allow(non_camel_case_types)]
92            enum __Field {
93                m_decls,
94                __ignore,
95            }
96            struct __FieldVisitor;
97            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
98                type Value = __Field;
99                fn expecting(
100                    &self,
101                    __formatter: &mut core::fmt::Formatter,
102                ) -> core::fmt::Result {
103                    core::fmt::Formatter::write_str(__formatter, "field identifier")
104                }
105                /// Intended for use in XML.
106                #[allow(clippy::match_single_binding)]
107                #[allow(clippy::reversed_empty_ranges)]
108                #[allow(clippy::single_match)]
109                fn visit_key<__E>(
110                    self,
111                    __value: &str,
112                ) -> core::result::Result<Self::Value, __E>
113                where
114                    __E: _serde::de::Error,
115                {
116                    match __value {
117                        "decls" => Ok(__Field::m_decls),
118                        _ => Ok(__Field::__ignore),
119                    }
120                }
121            }
122            impl<'de> _serde::Deserialize<'de> for __Field {
123                #[inline]
124                fn deserialize<__D>(
125                    __deserializer: __D,
126                ) -> core::result::Result<Self, __D::Error>
127                where
128                    __D: _serde::Deserializer<'de>,
129                {
130                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
131                }
132            }
133            struct __hkxVertexDescriptionVisitor<'de> {
134                marker: _serde::__private::PhantomData<hkxVertexDescription>,
135                lifetime: _serde::__private::PhantomData<&'de ()>,
136            }
137            #[allow(clippy::match_single_binding)]
138            #[allow(clippy::reversed_empty_ranges)]
139            #[allow(clippy::single_match)]
140            impl<'de> _serde::de::Visitor<'de> for __hkxVertexDescriptionVisitor<'de> {
141                type Value = hkxVertexDescription;
142                fn expecting(
143                    &self,
144                    __formatter: &mut core::fmt::Formatter,
145                ) -> core::fmt::Result {
146                    core::fmt::Formatter::write_str(
147                        __formatter,
148                        "struct hkxVertexDescription",
149                    )
150                }
151                fn visit_struct_for_bytes<__A>(
152                    self,
153                    mut __map: __A,
154                ) -> _serde::__private::Result<Self::Value, __A::Error>
155                where
156                    __A: _serde::de::MapAccess<'de>,
157                {
158                    let __ptr = __A::class_ptr(&mut __map);
159                    let mut m_decls: _serde::__private::Option<
160                        Vec<hkxVertexDescriptionElementDecl>,
161                    > = _serde::__private::None;
162                    for i in 0..1usize {
163                        match i {
164                            0usize => {
165                                if _serde::__private::Option::is_some(&m_decls) {
166                                    return _serde::__private::Err(
167                                        <__A::Error as _serde::de::Error>::duplicate_field("decls"),
168                                    );
169                                }
170                                m_decls = _serde::__private::Some(
171                                    match __A::next_value::<
172                                        Vec<hkxVertexDescriptionElementDecl>,
173                                    >(&mut __map) {
174                                        _serde::__private::Ok(__val) => __val,
175                                        _serde::__private::Err(__err) => {
176                                            return _serde::__private::Err(__err);
177                                        }
178                                    },
179                                );
180                            }
181                            _ => {}
182                        }
183                    }
184                    let m_decls = match m_decls {
185                        _serde::__private::Some(__field) => __field,
186                        _serde::__private::None => {
187                            return _serde::__private::Err(
188                                <__A::Error as _serde::de::Error>::missing_field("decls"),
189                            );
190                        }
191                    };
192                    _serde::__private::Ok(hkxVertexDescription {
193                        __ptr,
194                        m_decls,
195                    })
196                }
197                #[allow(clippy::manual_unwrap_or_default)]
198                fn visit_struct<__A>(
199                    self,
200                    mut __map: __A,
201                ) -> _serde::__private::Result<Self::Value, __A::Error>
202                where
203                    __A: _serde::de::MapAccess<'de>,
204                {
205                    let mut m_decls: _serde::__private::Option<
206                        Vec<hkxVertexDescriptionElementDecl>,
207                    > = _serde::__private::None;
208                    while let _serde::__private::Some(__key) = {
209                        __A::next_key::<__Field>(&mut __map)?
210                    } {
211                        match __key {
212                            __Field::m_decls => {
213                                #[cfg(
214                                    any(feature = "strict", feature = "ignore_duplicates")
215                                )]
216                                if _serde::__private::Option::is_some(&m_decls) {
217                                    #[cfg(feature = "ignore_duplicates")]
218                                    {
219                                        __A::skip_value(&mut __map)?;
220                                        continue;
221                                    }
222                                    #[cfg(feature = "strict")]
223                                    return _serde::__private::Err(
224                                        <__A::Error as _serde::de::Error>::duplicate_field("decls"),
225                                    );
226                                }
227                                m_decls = _serde::__private::Some(
228                                    match __A::next_value::<
229                                        Vec<hkxVertexDescriptionElementDecl>,
230                                    >(&mut __map) {
231                                        _serde::__private::Ok(__val) => __val,
232                                        _serde::__private::Err(__err) => {
233                                            return _serde::__private::Err(__err);
234                                        }
235                                    },
236                                );
237                            }
238                            _ => __A::skip_value(&mut __map)?,
239                        }
240                    }
241                    let m_decls = match m_decls {
242                        _serde::__private::Some(__field) => __field,
243                        _serde::__private::None => {
244                            #[cfg(feature = "strict")]
245                            return _serde::__private::Err(
246                                <__A::Error as _serde::de::Error>::missing_field("decls"),
247                            );
248                            #[cfg(not(feature = "strict"))] Default::default()
249                        }
250                    };
251                    let __ptr = __A::class_ptr(&mut __map);
252                    _serde::__private::Ok(hkxVertexDescription {
253                        __ptr,
254                        m_decls,
255                    })
256                }
257            }
258            const FIELDS: &[&str] = &["decls"];
259            _serde::Deserializer::deserialize_struct(
260                deserializer,
261                "hkxVertexDescription",
262                FIELDS,
263                __hkxVertexDescriptionVisitor {
264                    marker: _serde::__private::PhantomData::<hkxVertexDescription>,
265                    lifetime: _serde::__private::PhantomData,
266                },
267            )
268        }
269    }
270};
271/// # C++ Info
272/// - name: `DataType`(ctype: `hkEnum<DataType, hkUint16>`)
273#[allow(non_upper_case_globals, non_snake_case)]
274#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
275#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
276#[derive(
277    Debug,
278    Clone,
279    Default,
280    PartialEq,
281    Eq,
282    PartialOrd,
283    Ord,
284    num_derive::ToPrimitive,
285    num_derive::FromPrimitive,
286)]
287pub enum DataType {
288    #[default]
289    HKX_DT_NONE = 0isize,
290    HKX_DT_UINT8 = 1isize,
291    HKX_DT_INT16 = 2isize,
292    HKX_DT_UINT32 = 3isize,
293    HKX_DT_FLOAT = 4isize,
294}
295/// # C++ Info
296/// - name: `DataUsage`(ctype: `hkEnum<DataUsage, hkUint16>`)
297#[allow(non_upper_case_globals, non_snake_case)]
298#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
299#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
300#[derive(
301    Debug,
302    Clone,
303    Default,
304    PartialEq,
305    Eq,
306    PartialOrd,
307    Ord,
308    num_derive::ToPrimitive,
309    num_derive::FromPrimitive,
310)]
311pub enum DataUsage {
312    #[default]
313    HKX_DU_NONE = 0isize,
314    HKX_DU_POSITION = 1isize,
315    HKX_DU_COLOR = 2isize,
316    HKX_DU_NORMAL = 4isize,
317    HKX_DU_TANGENT = 8isize,
318    HKX_DU_BINORMAL = 16isize,
319    HKX_DU_TEXCOORD = 32isize,
320    HKX_DU_BLENDWEIGHTS = 64isize,
321    HKX_DU_BLENDINDICES = 128isize,
322    HKX_DU_USERDATA = 256isize,
323}
324const _: () = {
325    use havok_serde as __serde;
326    impl __serde::Serialize for DataType {
327        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
328        where
329            S: __serde::ser::Serializer,
330        {
331            let mut __serializer = __serializer.serialize_enum_flags()?;
332            match self {
333                Self::HKX_DT_NONE => __serializer.serialize_field("HKX_DT_NONE", &0u64),
334                Self::HKX_DT_UINT8 => __serializer.serialize_field("HKX_DT_UINT8", &1u64),
335                Self::HKX_DT_INT16 => __serializer.serialize_field("HKX_DT_INT16", &2u64),
336                Self::HKX_DT_UINT32 => {
337                    __serializer.serialize_field("HKX_DT_UINT32", &3u64)
338                }
339                Self::HKX_DT_FLOAT => __serializer.serialize_field("HKX_DT_FLOAT", &4u64),
340            }?;
341            use num_traits::ToPrimitive as _;
342            let num = self
343                .to_u16()
344                .ok_or(S::Error::custom("Failed enum DataType to_u16"))?;
345            __serializer.serialize_bits(&num)?;
346            __serializer.end()
347        }
348    }
349};
350const _: () = {
351    use havok_serde as __serde;
352    impl __serde::Serialize for DataUsage {
353        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
354        where
355            S: __serde::ser::Serializer,
356        {
357            let mut __serializer = __serializer.serialize_enum_flags()?;
358            match self {
359                Self::HKX_DU_NONE => __serializer.serialize_field("HKX_DU_NONE", &0u64),
360                Self::HKX_DU_POSITION => {
361                    __serializer.serialize_field("HKX_DU_POSITION", &1u64)
362                }
363                Self::HKX_DU_COLOR => __serializer.serialize_field("HKX_DU_COLOR", &2u64),
364                Self::HKX_DU_NORMAL => {
365                    __serializer.serialize_field("HKX_DU_NORMAL", &4u64)
366                }
367                Self::HKX_DU_TANGENT => {
368                    __serializer.serialize_field("HKX_DU_TANGENT", &8u64)
369                }
370                Self::HKX_DU_BINORMAL => {
371                    __serializer.serialize_field("HKX_DU_BINORMAL", &16u64)
372                }
373                Self::HKX_DU_TEXCOORD => {
374                    __serializer.serialize_field("HKX_DU_TEXCOORD", &32u64)
375                }
376                Self::HKX_DU_BLENDWEIGHTS => {
377                    __serializer.serialize_field("HKX_DU_BLENDWEIGHTS", &64u64)
378                }
379                Self::HKX_DU_BLENDINDICES => {
380                    __serializer.serialize_field("HKX_DU_BLENDINDICES", &128u64)
381                }
382                Self::HKX_DU_USERDATA => {
383                    __serializer.serialize_field("HKX_DU_USERDATA", &256u64)
384                }
385            }?;
386            use num_traits::ToPrimitive as _;
387            let num = self
388                .to_u16()
389                .ok_or(S::Error::custom("Failed enum DataUsage to_u16"))?;
390            __serializer.serialize_bits(&num)?;
391            __serializer.end()
392        }
393    }
394};
395#[doc(hidden)]
396#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
397const _: () = {
398    #[allow(unused_extern_crates, clippy::useless_attribute)]
399    extern crate havok_serde as _serde;
400    #[automatically_derived]
401    impl<'de> _serde::Deserialize<'de> for DataType {
402        fn deserialize<__D>(
403            __deserializer: __D,
404        ) -> _serde::__private::Result<Self, __D::Error>
405        where
406            __D: _serde::Deserializer<'de>,
407        {
408            #[allow(non_camel_case_types)]
409            #[doc(hidden)]
410            enum __Field {
411                __field0,
412                __field1,
413                __field2,
414                __field3,
415                __field4,
416            }
417            #[doc(hidden)]
418            struct __FieldVisitor;
419            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
420                type Value = __Field;
421                fn expecting(
422                    &self,
423                    __formatter: &mut _serde::__private::Formatter,
424                ) -> _serde::__private::fmt::Result {
425                    _serde::__private::Formatter::write_str(
426                        __formatter,
427                        "variant identifier",
428                    )
429                }
430                fn visit_uint16<__E>(
431                    self,
432                    __value: u16,
433                ) -> _serde::__private::Result<Self::Value, __E>
434                where
435                    __E: _serde::de::Error,
436                {
437                    match __value {
438                        0u16 => _serde::__private::Ok(__Field::__field0),
439                        1u16 => _serde::__private::Ok(__Field::__field1),
440                        2u16 => _serde::__private::Ok(__Field::__field2),
441                        3u16 => _serde::__private::Ok(__Field::__field3),
442                        4u16 => _serde::__private::Ok(__Field::__field4),
443                        _ => {
444                            _serde::__private::Err(
445                                _serde::de::Error::invalid_value(
446                                    _serde::de::Unexpected::Uint16(__value),
447                                    &"value(u16) of variant is one of 0, 1, 2, 3, 4",
448                                ),
449                            )
450                        }
451                    }
452                }
453                fn visit_stringptr<__E>(
454                    self,
455                    __value: StringPtr<'de>,
456                ) -> _serde::__private::Result<Self::Value, __E>
457                where
458                    __E: _serde::de::Error,
459                {
460                    if let Some(__value) = __value.into_inner() {
461                        match __value.as_ref() {
462                            v if v == "0" || v.eq_ignore_ascii_case("HKX_DT_NONE") => {
463                                _serde::__private::Ok(__Field::__field0)
464                            }
465                            v if v == "1" || v.eq_ignore_ascii_case("HKX_DT_UINT8") => {
466                                _serde::__private::Ok(__Field::__field1)
467                            }
468                            v if v == "2" || v.eq_ignore_ascii_case("HKX_DT_INT16") => {
469                                _serde::__private::Ok(__Field::__field2)
470                            }
471                            v if v == "3" || v.eq_ignore_ascii_case("HKX_DT_UINT32") => {
472                                _serde::__private::Ok(__Field::__field3)
473                            }
474                            v if v == "4" || v.eq_ignore_ascii_case("HKX_DT_FLOAT") => {
475                                _serde::__private::Ok(__Field::__field4)
476                            }
477                            _ => {
478                                _serde::__private::Err(
479                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
480                                )
481                            }
482                        }
483                    } else {
484                        _serde::__private::Err(
485                            _serde::de::Error::unknown_variant("None", VARIANTS),
486                        )
487                    }
488                }
489            }
490            impl<'de> _serde::Deserialize<'de> for __Field {
491                #[inline]
492                fn deserialize<__D>(
493                    __deserializer: __D,
494                ) -> _serde::__private::Result<Self, __D::Error>
495                where
496                    __D: _serde::Deserializer<'de>,
497                {
498                    _serde::Deserializer::deserialize_identifier(
499                        __deserializer,
500                        _serde::de::ReadEnumSize::Uint16,
501                        __FieldVisitor,
502                    )
503                }
504            }
505            #[doc(hidden)]
506            struct __Visitor<'de> {
507                marker: _serde::__private::PhantomData<DataType>,
508                lifetime: _serde::__private::PhantomData<&'de ()>,
509            }
510            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
511                type Value = DataType;
512                fn expecting(
513                    &self,
514                    __formatter: &mut _serde::__private::Formatter,
515                ) -> _serde::__private::fmt::Result {
516                    _serde::__private::Formatter::write_str(__formatter, "enum DataType")
517                }
518                fn visit_enum<__A>(
519                    self,
520                    __data: __A,
521                ) -> _serde::__private::Result<Self::Value, __A::Error>
522                where
523                    __A: _serde::de::EnumAccess<'de>,
524                {
525                    match _serde::de::EnumAccess::variant(__data)? {
526                        (__Field::__field0, __variant) => {
527                            _serde::de::VariantAccess::unit_variant(__variant)?;
528                            _serde::__private::Ok(DataType::HKX_DT_NONE)
529                        }
530                        (__Field::__field1, __variant) => {
531                            _serde::de::VariantAccess::unit_variant(__variant)?;
532                            _serde::__private::Ok(DataType::HKX_DT_UINT8)
533                        }
534                        (__Field::__field2, __variant) => {
535                            _serde::de::VariantAccess::unit_variant(__variant)?;
536                            _serde::__private::Ok(DataType::HKX_DT_INT16)
537                        }
538                        (__Field::__field3, __variant) => {
539                            _serde::de::VariantAccess::unit_variant(__variant)?;
540                            _serde::__private::Ok(DataType::HKX_DT_UINT32)
541                        }
542                        (__Field::__field4, __variant) => {
543                            _serde::de::VariantAccess::unit_variant(__variant)?;
544                            _serde::__private::Ok(DataType::HKX_DT_FLOAT)
545                        }
546                    }
547                }
548            }
549            #[doc(hidden)]
550            const VARIANTS: &'static [&'static str] = &[
551                "HKX_DT_NONE",
552                "HKX_DT_UINT8",
553                "HKX_DT_INT16",
554                "HKX_DT_UINT32",
555                "HKX_DT_FLOAT",
556            ];
557            _serde::Deserializer::deserialize_enum(
558                __deserializer,
559                "DataType",
560                VARIANTS,
561                __Visitor {
562                    marker: _serde::__private::PhantomData::<DataType>,
563                    lifetime: _serde::__private::PhantomData,
564                },
565            )
566        }
567    }
568};
569#[doc(hidden)]
570#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
571const _: () = {
572    #[allow(unused_extern_crates, clippy::useless_attribute)]
573    extern crate havok_serde as _serde;
574    #[automatically_derived]
575    impl<'de> _serde::Deserialize<'de> for DataUsage {
576        fn deserialize<__D>(
577            __deserializer: __D,
578        ) -> _serde::__private::Result<Self, __D::Error>
579        where
580            __D: _serde::Deserializer<'de>,
581        {
582            #[allow(non_camel_case_types)]
583            #[doc(hidden)]
584            enum __Field {
585                __field0,
586                __field1,
587                __field2,
588                __field3,
589                __field4,
590                __field5,
591                __field6,
592                __field7,
593                __field8,
594                __field9,
595            }
596            #[doc(hidden)]
597            struct __FieldVisitor;
598            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
599                type Value = __Field;
600                fn expecting(
601                    &self,
602                    __formatter: &mut _serde::__private::Formatter,
603                ) -> _serde::__private::fmt::Result {
604                    _serde::__private::Formatter::write_str(
605                        __formatter,
606                        "variant identifier",
607                    )
608                }
609                fn visit_uint16<__E>(
610                    self,
611                    __value: u16,
612                ) -> _serde::__private::Result<Self::Value, __E>
613                where
614                    __E: _serde::de::Error,
615                {
616                    match __value {
617                        0u16 => _serde::__private::Ok(__Field::__field0),
618                        1u16 => _serde::__private::Ok(__Field::__field1),
619                        2u16 => _serde::__private::Ok(__Field::__field2),
620                        4u16 => _serde::__private::Ok(__Field::__field3),
621                        8u16 => _serde::__private::Ok(__Field::__field4),
622                        16u16 => _serde::__private::Ok(__Field::__field5),
623                        32u16 => _serde::__private::Ok(__Field::__field6),
624                        64u16 => _serde::__private::Ok(__Field::__field7),
625                        128u16 => _serde::__private::Ok(__Field::__field8),
626                        256u16 => _serde::__private::Ok(__Field::__field9),
627                        _ => {
628                            _serde::__private::Err(
629                                _serde::de::Error::invalid_value(
630                                    _serde::de::Unexpected::Uint16(__value),
631                                    &"value(u16) of variant is one of 0, 1, 2, 4, 8, 16, 32, 64, 128, 256",
632                                ),
633                            )
634                        }
635                    }
636                }
637                fn visit_stringptr<__E>(
638                    self,
639                    __value: StringPtr<'de>,
640                ) -> _serde::__private::Result<Self::Value, __E>
641                where
642                    __E: _serde::de::Error,
643                {
644                    if let Some(__value) = __value.into_inner() {
645                        match __value.as_ref() {
646                            v if v == "0" || v.eq_ignore_ascii_case("HKX_DU_NONE") => {
647                                _serde::__private::Ok(__Field::__field0)
648                            }
649                            v if v == "1"
650                                || v.eq_ignore_ascii_case("HKX_DU_POSITION") => {
651                                _serde::__private::Ok(__Field::__field1)
652                            }
653                            v if v == "2" || v.eq_ignore_ascii_case("HKX_DU_COLOR") => {
654                                _serde::__private::Ok(__Field::__field2)
655                            }
656                            v if v == "4" || v.eq_ignore_ascii_case("HKX_DU_NORMAL") => {
657                                _serde::__private::Ok(__Field::__field3)
658                            }
659                            v if v == "8" || v.eq_ignore_ascii_case("HKX_DU_TANGENT") => {
660                                _serde::__private::Ok(__Field::__field4)
661                            }
662                            v if v == "16"
663                                || v.eq_ignore_ascii_case("HKX_DU_BINORMAL") => {
664                                _serde::__private::Ok(__Field::__field5)
665                            }
666                            v if v == "32"
667                                || v.eq_ignore_ascii_case("HKX_DU_TEXCOORD") => {
668                                _serde::__private::Ok(__Field::__field6)
669                            }
670                            v if v == "64"
671                                || v.eq_ignore_ascii_case("HKX_DU_BLENDWEIGHTS") => {
672                                _serde::__private::Ok(__Field::__field7)
673                            }
674                            v if v == "128"
675                                || v.eq_ignore_ascii_case("HKX_DU_BLENDINDICES") => {
676                                _serde::__private::Ok(__Field::__field8)
677                            }
678                            v if v == "256"
679                                || v.eq_ignore_ascii_case("HKX_DU_USERDATA") => {
680                                _serde::__private::Ok(__Field::__field9)
681                            }
682                            _ => {
683                                _serde::__private::Err(
684                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
685                                )
686                            }
687                        }
688                    } else {
689                        _serde::__private::Err(
690                            _serde::de::Error::unknown_variant("None", VARIANTS),
691                        )
692                    }
693                }
694            }
695            impl<'de> _serde::Deserialize<'de> for __Field {
696                #[inline]
697                fn deserialize<__D>(
698                    __deserializer: __D,
699                ) -> _serde::__private::Result<Self, __D::Error>
700                where
701                    __D: _serde::Deserializer<'de>,
702                {
703                    _serde::Deserializer::deserialize_identifier(
704                        __deserializer,
705                        _serde::de::ReadEnumSize::Uint16,
706                        __FieldVisitor,
707                    )
708                }
709            }
710            #[doc(hidden)]
711            struct __Visitor<'de> {
712                marker: _serde::__private::PhantomData<DataUsage>,
713                lifetime: _serde::__private::PhantomData<&'de ()>,
714            }
715            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
716                type Value = DataUsage;
717                fn expecting(
718                    &self,
719                    __formatter: &mut _serde::__private::Formatter,
720                ) -> _serde::__private::fmt::Result {
721                    _serde::__private::Formatter::write_str(
722                        __formatter,
723                        "enum DataUsage",
724                    )
725                }
726                fn visit_enum<__A>(
727                    self,
728                    __data: __A,
729                ) -> _serde::__private::Result<Self::Value, __A::Error>
730                where
731                    __A: _serde::de::EnumAccess<'de>,
732                {
733                    match _serde::de::EnumAccess::variant(__data)? {
734                        (__Field::__field0, __variant) => {
735                            _serde::de::VariantAccess::unit_variant(__variant)?;
736                            _serde::__private::Ok(DataUsage::HKX_DU_NONE)
737                        }
738                        (__Field::__field1, __variant) => {
739                            _serde::de::VariantAccess::unit_variant(__variant)?;
740                            _serde::__private::Ok(DataUsage::HKX_DU_POSITION)
741                        }
742                        (__Field::__field2, __variant) => {
743                            _serde::de::VariantAccess::unit_variant(__variant)?;
744                            _serde::__private::Ok(DataUsage::HKX_DU_COLOR)
745                        }
746                        (__Field::__field3, __variant) => {
747                            _serde::de::VariantAccess::unit_variant(__variant)?;
748                            _serde::__private::Ok(DataUsage::HKX_DU_NORMAL)
749                        }
750                        (__Field::__field4, __variant) => {
751                            _serde::de::VariantAccess::unit_variant(__variant)?;
752                            _serde::__private::Ok(DataUsage::HKX_DU_TANGENT)
753                        }
754                        (__Field::__field5, __variant) => {
755                            _serde::de::VariantAccess::unit_variant(__variant)?;
756                            _serde::__private::Ok(DataUsage::HKX_DU_BINORMAL)
757                        }
758                        (__Field::__field6, __variant) => {
759                            _serde::de::VariantAccess::unit_variant(__variant)?;
760                            _serde::__private::Ok(DataUsage::HKX_DU_TEXCOORD)
761                        }
762                        (__Field::__field7, __variant) => {
763                            _serde::de::VariantAccess::unit_variant(__variant)?;
764                            _serde::__private::Ok(DataUsage::HKX_DU_BLENDWEIGHTS)
765                        }
766                        (__Field::__field8, __variant) => {
767                            _serde::de::VariantAccess::unit_variant(__variant)?;
768                            _serde::__private::Ok(DataUsage::HKX_DU_BLENDINDICES)
769                        }
770                        (__Field::__field9, __variant) => {
771                            _serde::de::VariantAccess::unit_variant(__variant)?;
772                            _serde::__private::Ok(DataUsage::HKX_DU_USERDATA)
773                        }
774                    }
775                }
776            }
777            #[doc(hidden)]
778            const VARIANTS: &'static [&'static str] = &[
779                "HKX_DU_NONE",
780                "HKX_DU_POSITION",
781                "HKX_DU_COLOR",
782                "HKX_DU_NORMAL",
783                "HKX_DU_TANGENT",
784                "HKX_DU_BINORMAL",
785                "HKX_DU_TEXCOORD",
786                "HKX_DU_BLENDWEIGHTS",
787                "HKX_DU_BLENDINDICES",
788                "HKX_DU_USERDATA",
789            ];
790            _serde::Deserializer::deserialize_enum(
791                __deserializer,
792                "DataUsage",
793                VARIANTS,
794                __Visitor {
795                    marker: _serde::__private::PhantomData::<DataUsage>,
796                    lifetime: _serde::__private::PhantomData,
797                },
798            )
799        }
800    }
801};