havok_classes/generated/
hkMeshTexture_.rs

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