havok_classes/generated/
hkxMaterial_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkxMaterial`
5/// - version: `1`
6/// - signature: `0x2954537a`
7/// - size: `144`(x86)/`176`(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 hkxMaterial<'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    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkxAttributeHolder<'a>,
31    /// # C++ Info
32    /// - name: `name`(ctype: `hkStringPtr`)
33    /// - offset: ` 20`(x86)/` 32`(x86_64)
34    /// - type_size: `  4`(x86)/`  8`(x86_64)
35    #[cfg_attr(feature = "serde", serde(borrow))]
36    #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
37    #[cfg_attr(feature = "serde", serde(rename = "name"))]
38    pub m_name: StringPtr<'a>,
39    /// # C++ Info
40    /// - name: `stages`(ctype: `hkArray<struct hkxMaterialTextureStage>`)
41    /// - offset: ` 24`(x86)/` 40`(x86_64)
42    /// - type_size: ` 12`(x86)/` 16`(x86_64)
43    #[cfg_attr(feature = "json_schema", schemars(rename = "stages"))]
44    #[cfg_attr(feature = "serde", serde(rename = "stages"))]
45    pub m_stages: Vec<hkxMaterialTextureStage>,
46    /// # C++ Info
47    /// - name: `diffuseColor`(ctype: `hkVector4`)
48    /// - offset: ` 48`(x86)/` 64`(x86_64)
49    /// - type_size: ` 16`(x86)/` 16`(x86_64)
50    #[cfg_attr(feature = "json_schema", schemars(rename = "diffuseColor"))]
51    #[cfg_attr(feature = "serde", serde(rename = "diffuseColor"))]
52    pub m_diffuseColor: Vector4,
53    /// # C++ Info
54    /// - name: `ambientColor`(ctype: `hkVector4`)
55    /// - offset: ` 64`(x86)/` 80`(x86_64)
56    /// - type_size: ` 16`(x86)/` 16`(x86_64)
57    #[cfg_attr(feature = "json_schema", schemars(rename = "ambientColor"))]
58    #[cfg_attr(feature = "serde", serde(rename = "ambientColor"))]
59    pub m_ambientColor: Vector4,
60    /// # C++ Info
61    /// - name: `specularColor`(ctype: `hkVector4`)
62    /// - offset: ` 80`(x86)/` 96`(x86_64)
63    /// - type_size: ` 16`(x86)/` 16`(x86_64)
64    #[cfg_attr(feature = "json_schema", schemars(rename = "specularColor"))]
65    #[cfg_attr(feature = "serde", serde(rename = "specularColor"))]
66    pub m_specularColor: Vector4,
67    /// # C++ Info
68    /// - name: `emissiveColor`(ctype: `hkVector4`)
69    /// - offset: ` 96`(x86)/`112`(x86_64)
70    /// - type_size: ` 16`(x86)/` 16`(x86_64)
71    #[cfg_attr(feature = "json_schema", schemars(rename = "emissiveColor"))]
72    #[cfg_attr(feature = "serde", serde(rename = "emissiveColor"))]
73    pub m_emissiveColor: Vector4,
74    /// # C++ Info
75    /// - name: `subMaterials`(ctype: `hkArray<hkxMaterial*>`)
76    /// - offset: `112`(x86)/`128`(x86_64)
77    /// - type_size: ` 12`(x86)/` 16`(x86_64)
78    #[cfg_attr(feature = "json_schema", schemars(rename = "subMaterials"))]
79    #[cfg_attr(feature = "serde", serde(rename = "subMaterials"))]
80    pub m_subMaterials: Vec<Pointer>,
81    /// # C++ Info
82    /// - name: `extraData`(ctype: `struct hkReferencedObject*`)
83    /// - offset: `124`(x86)/`144`(x86_64)
84    /// - type_size: `  4`(x86)/`  8`(x86_64)
85    #[cfg_attr(feature = "json_schema", schemars(rename = "extraData"))]
86    #[cfg_attr(feature = "serde", serde(rename = "extraData"))]
87    pub m_extraData: Pointer,
88    /// # C++ Info
89    /// - name: `properties`(ctype: `hkArray<struct hkxMaterialProperty>`)
90    /// - offset: `128`(x86)/`152`(x86_64)
91    /// - type_size: ` 12`(x86)/` 16`(x86_64)
92    #[cfg_attr(feature = "json_schema", schemars(rename = "properties"))]
93    #[cfg_attr(feature = "serde", serde(rename = "properties"))]
94    pub m_properties: Vec<hkxMaterialProperty>,
95}
96const _: () = {
97    use havok_serde as _serde;
98    impl<'a> _serde::HavokClass for hkxMaterial<'a> {
99        #[inline]
100        fn name(&self) -> &'static str {
101            "hkxMaterial"
102        }
103        #[inline]
104        fn signature(&self) -> _serde::__private::Signature {
105            _serde::__private::Signature::new(0x2954537a)
106        }
107        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
108        fn deps_indexes(&self) -> Vec<usize> {
109            let mut v = Vec::new();
110            v.extend(
111                self
112                    .parent
113                    .m_attributeGroups
114                    .iter()
115                    .flat_map(|class| class.deps_indexes())
116                    .collect::<Vec<usize>>(),
117            );
118            v.extend(
119                self
120                    .m_stages
121                    .iter()
122                    .flat_map(|class| class.deps_indexes())
123                    .collect::<Vec<usize>>(),
124            );
125            v.extend(self.m_subMaterials.iter().map(|ptr| ptr.get()));
126            v.push(self.m_extraData.get());
127            v.extend(
128                self
129                    .m_properties
130                    .iter()
131                    .flat_map(|class| class.deps_indexes())
132                    .collect::<Vec<usize>>(),
133            );
134            v
135        }
136    }
137    impl<'a> _serde::Serialize for hkxMaterial<'a> {
138        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
139        where
140            S: _serde::ser::Serializer,
141        {
142            let class_meta = self
143                .__ptr
144                .map(|name| (name, _serde::__private::Signature::new(0x2954537a)));
145            let mut serializer = __serializer
146                .serialize_struct("hkxMaterial", class_meta, (144u64, 176u64))?;
147            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
148            serializer
149                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
150            serializer
151                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
152            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
153            serializer
154                .serialize_array_field(
155                    "attributeGroups",
156                    &self.parent.m_attributeGroups,
157                    TypeSize::Struct {
158                        size_x86: 16u64,
159                        size_x86_64: 24u64,
160                    },
161                )?;
162            serializer.serialize_field("name", &self.m_name)?;
163            serializer
164                .serialize_array_field(
165                    "stages",
166                    &self.m_stages,
167                    TypeSize::Struct {
168                        size_x86: 12u64,
169                        size_x86_64: 16u64,
170                    },
171                )?;
172            serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
173            serializer.serialize_field("diffuseColor", &self.m_diffuseColor)?;
174            serializer.serialize_field("ambientColor", &self.m_ambientColor)?;
175            serializer.serialize_field("specularColor", &self.m_specularColor)?;
176            serializer.serialize_field("emissiveColor", &self.m_emissiveColor)?;
177            serializer
178                .serialize_array_field(
179                    "subMaterials",
180                    &self.m_subMaterials,
181                    TypeSize::NonPtr,
182                )?;
183            serializer.serialize_field("extraData", &self.m_extraData)?;
184            serializer
185                .serialize_array_field(
186                    "properties",
187                    &self.m_properties,
188                    TypeSize::Struct {
189                        size_x86: 8u64,
190                        size_x86_64: 8u64,
191                    },
192                )?;
193            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
194            serializer.end()
195        }
196    }
197};
198#[doc(hidden)]
199#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
200const _: () = {
201    use havok_serde as _serde;
202    #[automatically_derived]
203    impl<'de> _serde::Deserialize<'de> for hkxMaterial<'de> {
204        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
205        where
206            __D: _serde::Deserializer<'de>,
207        {
208            #[allow(non_camel_case_types)]
209            enum __Field {
210                m_attributeGroups,
211                m_name,
212                m_stages,
213                m_diffuseColor,
214                m_ambientColor,
215                m_specularColor,
216                m_emissiveColor,
217                m_subMaterials,
218                m_extraData,
219                m_properties,
220                __ignore,
221            }
222            struct __FieldVisitor;
223            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
224                type Value = __Field;
225                fn expecting(
226                    &self,
227                    __formatter: &mut core::fmt::Formatter,
228                ) -> core::fmt::Result {
229                    core::fmt::Formatter::write_str(__formatter, "field identifier")
230                }
231                /// Intended for use in XML.
232                #[allow(clippy::match_single_binding)]
233                #[allow(clippy::reversed_empty_ranges)]
234                #[allow(clippy::single_match)]
235                fn visit_key<__E>(
236                    self,
237                    __value: &str,
238                ) -> core::result::Result<Self::Value, __E>
239                where
240                    __E: _serde::de::Error,
241                {
242                    match __value {
243                        "attributeGroups" => Ok(__Field::m_attributeGroups),
244                        "name" => Ok(__Field::m_name),
245                        "stages" => Ok(__Field::m_stages),
246                        "diffuseColor" => Ok(__Field::m_diffuseColor),
247                        "ambientColor" => Ok(__Field::m_ambientColor),
248                        "specularColor" => Ok(__Field::m_specularColor),
249                        "emissiveColor" => Ok(__Field::m_emissiveColor),
250                        "subMaterials" => Ok(__Field::m_subMaterials),
251                        "extraData" => Ok(__Field::m_extraData),
252                        "properties" => Ok(__Field::m_properties),
253                        _ => Ok(__Field::__ignore),
254                    }
255                }
256            }
257            impl<'de> _serde::Deserialize<'de> for __Field {
258                #[inline]
259                fn deserialize<__D>(
260                    __deserializer: __D,
261                ) -> core::result::Result<Self, __D::Error>
262                where
263                    __D: _serde::Deserializer<'de>,
264                {
265                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
266                }
267            }
268            struct __hkxMaterialVisitor<'de> {
269                marker: _serde::__private::PhantomData<hkxMaterial<'de>>,
270                lifetime: _serde::__private::PhantomData<&'de ()>,
271            }
272            #[allow(clippy::match_single_binding)]
273            #[allow(clippy::reversed_empty_ranges)]
274            #[allow(clippy::single_match)]
275            impl<'de> _serde::de::Visitor<'de> for __hkxMaterialVisitor<'de> {
276                type Value = hkxMaterial<'de>;
277                fn expecting(
278                    &self,
279                    __formatter: &mut core::fmt::Formatter,
280                ) -> core::fmt::Result {
281                    core::fmt::Formatter::write_str(__formatter, "struct hkxMaterial")
282                }
283                fn visit_struct_for_bytes<__A>(
284                    self,
285                    mut __map: __A,
286                ) -> _serde::__private::Result<Self::Value, __A::Error>
287                where
288                    __A: _serde::de::MapAccess<'de>,
289                {
290                    let __ptr = __A::class_ptr(&mut __map);
291                    let parent = __A::parent_value(&mut __map)?;
292                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
293                    let mut m_stages: _serde::__private::Option<
294                        Vec<hkxMaterialTextureStage>,
295                    > = _serde::__private::None;
296                    let mut m_diffuseColor: _serde::__private::Option<Vector4> = _serde::__private::None;
297                    let mut m_ambientColor: _serde::__private::Option<Vector4> = _serde::__private::None;
298                    let mut m_specularColor: _serde::__private::Option<Vector4> = _serde::__private::None;
299                    let mut m_emissiveColor: _serde::__private::Option<Vector4> = _serde::__private::None;
300                    let mut m_subMaterials: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
301                    let mut m_extraData: _serde::__private::Option<Pointer> = _serde::__private::None;
302                    let mut m_properties: _serde::__private::Option<
303                        Vec<hkxMaterialProperty>,
304                    > = _serde::__private::None;
305                    for i in 0..9usize {
306                        match i {
307                            0usize => {
308                                if _serde::__private::Option::is_some(&m_name) {
309                                    return _serde::__private::Err(
310                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
311                                    );
312                                }
313                                m_name = _serde::__private::Some(
314                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
315                                        _serde::__private::Ok(__val) => __val,
316                                        _serde::__private::Err(__err) => {
317                                            return _serde::__private::Err(__err);
318                                        }
319                                    },
320                                );
321                            }
322                            1usize => {
323                                if _serde::__private::Option::is_some(&m_stages) {
324                                    return _serde::__private::Err(
325                                        <__A::Error as _serde::de::Error>::duplicate_field("stages"),
326                                    );
327                                }
328                                m_stages = _serde::__private::Some(
329                                    match __A::next_value::<
330                                        Vec<hkxMaterialTextureStage>,
331                                    >(&mut __map) {
332                                        _serde::__private::Ok(__val) => __val,
333                                        _serde::__private::Err(__err) => {
334                                            return _serde::__private::Err(__err);
335                                        }
336                                    },
337                                );
338                            }
339                            2usize => {
340                                if _serde::__private::Option::is_some(&m_diffuseColor) {
341                                    return _serde::__private::Err(
342                                        <__A::Error as _serde::de::Error>::duplicate_field(
343                                            "diffuseColor",
344                                        ),
345                                    );
346                                }
347                                __A::pad(&mut __map, 12usize, 8usize)?;
348                                m_diffuseColor = _serde::__private::Some(
349                                    match __A::next_value::<Vector4>(&mut __map) {
350                                        _serde::__private::Ok(__val) => __val,
351                                        _serde::__private::Err(__err) => {
352                                            return _serde::__private::Err(__err);
353                                        }
354                                    },
355                                );
356                            }
357                            3usize => {
358                                if _serde::__private::Option::is_some(&m_ambientColor) {
359                                    return _serde::__private::Err(
360                                        <__A::Error as _serde::de::Error>::duplicate_field(
361                                            "ambientColor",
362                                        ),
363                                    );
364                                }
365                                m_ambientColor = _serde::__private::Some(
366                                    match __A::next_value::<Vector4>(&mut __map) {
367                                        _serde::__private::Ok(__val) => __val,
368                                        _serde::__private::Err(__err) => {
369                                            return _serde::__private::Err(__err);
370                                        }
371                                    },
372                                );
373                            }
374                            4usize => {
375                                if _serde::__private::Option::is_some(&m_specularColor) {
376                                    return _serde::__private::Err(
377                                        <__A::Error as _serde::de::Error>::duplicate_field(
378                                            "specularColor",
379                                        ),
380                                    );
381                                }
382                                m_specularColor = _serde::__private::Some(
383                                    match __A::next_value::<Vector4>(&mut __map) {
384                                        _serde::__private::Ok(__val) => __val,
385                                        _serde::__private::Err(__err) => {
386                                            return _serde::__private::Err(__err);
387                                        }
388                                    },
389                                );
390                            }
391                            5usize => {
392                                if _serde::__private::Option::is_some(&m_emissiveColor) {
393                                    return _serde::__private::Err(
394                                        <__A::Error as _serde::de::Error>::duplicate_field(
395                                            "emissiveColor",
396                                        ),
397                                    );
398                                }
399                                m_emissiveColor = _serde::__private::Some(
400                                    match __A::next_value::<Vector4>(&mut __map) {
401                                        _serde::__private::Ok(__val) => __val,
402                                        _serde::__private::Err(__err) => {
403                                            return _serde::__private::Err(__err);
404                                        }
405                                    },
406                                );
407                            }
408                            6usize => {
409                                if _serde::__private::Option::is_some(&m_subMaterials) {
410                                    return _serde::__private::Err(
411                                        <__A::Error as _serde::de::Error>::duplicate_field(
412                                            "subMaterials",
413                                        ),
414                                    );
415                                }
416                                m_subMaterials = _serde::__private::Some(
417                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
418                                        _serde::__private::Ok(__val) => __val,
419                                        _serde::__private::Err(__err) => {
420                                            return _serde::__private::Err(__err);
421                                        }
422                                    },
423                                );
424                            }
425                            7usize => {
426                                if _serde::__private::Option::is_some(&m_extraData) {
427                                    return _serde::__private::Err(
428                                        <__A::Error as _serde::de::Error>::duplicate_field(
429                                            "extraData",
430                                        ),
431                                    );
432                                }
433                                m_extraData = _serde::__private::Some(
434                                    match __A::next_value::<Pointer>(&mut __map) {
435                                        _serde::__private::Ok(__val) => __val,
436                                        _serde::__private::Err(__err) => {
437                                            return _serde::__private::Err(__err);
438                                        }
439                                    },
440                                );
441                            }
442                            8usize => {
443                                if _serde::__private::Option::is_some(&m_properties) {
444                                    return _serde::__private::Err(
445                                        <__A::Error as _serde::de::Error>::duplicate_field(
446                                            "properties",
447                                        ),
448                                    );
449                                }
450                                m_properties = _serde::__private::Some(
451                                    match __A::next_value::<
452                                        Vec<hkxMaterialProperty>,
453                                    >(&mut __map) {
454                                        _serde::__private::Ok(__val) => __val,
455                                        _serde::__private::Err(__err) => {
456                                            return _serde::__private::Err(__err);
457                                        }
458                                    },
459                                );
460                            }
461                            _ => {}
462                        }
463                    }
464                    __A::pad(&mut __map, 4usize, 8usize)?;
465                    let m_name = match m_name {
466                        _serde::__private::Some(__field) => __field,
467                        _serde::__private::None => {
468                            return _serde::__private::Err(
469                                <__A::Error as _serde::de::Error>::missing_field("name"),
470                            );
471                        }
472                    };
473                    let m_stages = match m_stages {
474                        _serde::__private::Some(__field) => __field,
475                        _serde::__private::None => {
476                            return _serde::__private::Err(
477                                <__A::Error as _serde::de::Error>::missing_field("stages"),
478                            );
479                        }
480                    };
481                    let m_diffuseColor = match m_diffuseColor {
482                        _serde::__private::Some(__field) => __field,
483                        _serde::__private::None => {
484                            return _serde::__private::Err(
485                                <__A::Error as _serde::de::Error>::missing_field(
486                                    "diffuseColor",
487                                ),
488                            );
489                        }
490                    };
491                    let m_ambientColor = match m_ambientColor {
492                        _serde::__private::Some(__field) => __field,
493                        _serde::__private::None => {
494                            return _serde::__private::Err(
495                                <__A::Error as _serde::de::Error>::missing_field(
496                                    "ambientColor",
497                                ),
498                            );
499                        }
500                    };
501                    let m_specularColor = match m_specularColor {
502                        _serde::__private::Some(__field) => __field,
503                        _serde::__private::None => {
504                            return _serde::__private::Err(
505                                <__A::Error as _serde::de::Error>::missing_field(
506                                    "specularColor",
507                                ),
508                            );
509                        }
510                    };
511                    let m_emissiveColor = match m_emissiveColor {
512                        _serde::__private::Some(__field) => __field,
513                        _serde::__private::None => {
514                            return _serde::__private::Err(
515                                <__A::Error as _serde::de::Error>::missing_field(
516                                    "emissiveColor",
517                                ),
518                            );
519                        }
520                    };
521                    let m_subMaterials = match m_subMaterials {
522                        _serde::__private::Some(__field) => __field,
523                        _serde::__private::None => {
524                            return _serde::__private::Err(
525                                <__A::Error as _serde::de::Error>::missing_field(
526                                    "subMaterials",
527                                ),
528                            );
529                        }
530                    };
531                    let m_extraData = match m_extraData {
532                        _serde::__private::Some(__field) => __field,
533                        _serde::__private::None => {
534                            return _serde::__private::Err(
535                                <__A::Error as _serde::de::Error>::missing_field(
536                                    "extraData",
537                                ),
538                            );
539                        }
540                    };
541                    let m_properties = match m_properties {
542                        _serde::__private::Some(__field) => __field,
543                        _serde::__private::None => {
544                            return _serde::__private::Err(
545                                <__A::Error as _serde::de::Error>::missing_field(
546                                    "properties",
547                                ),
548                            );
549                        }
550                    };
551                    _serde::__private::Ok(hkxMaterial {
552                        __ptr,
553                        parent,
554                        m_name,
555                        m_stages,
556                        m_diffuseColor,
557                        m_ambientColor,
558                        m_specularColor,
559                        m_emissiveColor,
560                        m_subMaterials,
561                        m_extraData,
562                        m_properties,
563                    })
564                }
565                #[allow(clippy::manual_unwrap_or_default)]
566                fn visit_struct<__A>(
567                    self,
568                    mut __map: __A,
569                ) -> _serde::__private::Result<Self::Value, __A::Error>
570                where
571                    __A: _serde::de::MapAccess<'de>,
572                {
573                    let mut m_attributeGroups: _serde::__private::Option<
574                        Vec<hkxAttributeGroup<'de>>,
575                    > = _serde::__private::None;
576                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
577                    let mut m_stages: _serde::__private::Option<
578                        Vec<hkxMaterialTextureStage>,
579                    > = _serde::__private::None;
580                    let mut m_diffuseColor: _serde::__private::Option<Vector4> = _serde::__private::None;
581                    let mut m_ambientColor: _serde::__private::Option<Vector4> = _serde::__private::None;
582                    let mut m_specularColor: _serde::__private::Option<Vector4> = _serde::__private::None;
583                    let mut m_emissiveColor: _serde::__private::Option<Vector4> = _serde::__private::None;
584                    let mut m_subMaterials: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
585                    let mut m_extraData: _serde::__private::Option<Pointer> = _serde::__private::None;
586                    let mut m_properties: _serde::__private::Option<
587                        Vec<hkxMaterialProperty>,
588                    > = _serde::__private::None;
589                    while let _serde::__private::Some(__key) = {
590                        __A::next_key::<__Field>(&mut __map)?
591                    } {
592                        match __key {
593                            __Field::m_attributeGroups => {
594                                #[cfg(
595                                    any(feature = "strict", feature = "ignore_duplicates")
596                                )]
597                                if _serde::__private::Option::is_some(&m_attributeGroups) {
598                                    #[cfg(feature = "ignore_duplicates")]
599                                    {
600                                        __A::skip_value(&mut __map)?;
601                                        continue;
602                                    }
603                                    #[cfg(feature = "strict")]
604                                    return _serde::__private::Err(
605                                        <__A::Error as _serde::de::Error>::duplicate_field(
606                                            "attributeGroups",
607                                        ),
608                                    );
609                                }
610                                m_attributeGroups = _serde::__private::Some(
611                                    match __A::next_value::<
612                                        Vec<hkxAttributeGroup<'de>>,
613                                    >(&mut __map) {
614                                        _serde::__private::Ok(__val) => __val,
615                                        _serde::__private::Err(__err) => {
616                                            return _serde::__private::Err(__err);
617                                        }
618                                    },
619                                );
620                            }
621                            __Field::m_name => {
622                                #[cfg(
623                                    any(feature = "strict", feature = "ignore_duplicates")
624                                )]
625                                if _serde::__private::Option::is_some(&m_name) {
626                                    #[cfg(feature = "ignore_duplicates")]
627                                    {
628                                        __A::skip_value(&mut __map)?;
629                                        continue;
630                                    }
631                                    #[cfg(feature = "strict")]
632                                    return _serde::__private::Err(
633                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
634                                    );
635                                }
636                                m_name = _serde::__private::Some(
637                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
638                                        _serde::__private::Ok(__val) => __val,
639                                        _serde::__private::Err(__err) => {
640                                            return _serde::__private::Err(__err);
641                                        }
642                                    },
643                                );
644                            }
645                            __Field::m_stages => {
646                                #[cfg(
647                                    any(feature = "strict", feature = "ignore_duplicates")
648                                )]
649                                if _serde::__private::Option::is_some(&m_stages) {
650                                    #[cfg(feature = "ignore_duplicates")]
651                                    {
652                                        __A::skip_value(&mut __map)?;
653                                        continue;
654                                    }
655                                    #[cfg(feature = "strict")]
656                                    return _serde::__private::Err(
657                                        <__A::Error as _serde::de::Error>::duplicate_field("stages"),
658                                    );
659                                }
660                                m_stages = _serde::__private::Some(
661                                    match __A::next_value::<
662                                        Vec<hkxMaterialTextureStage>,
663                                    >(&mut __map) {
664                                        _serde::__private::Ok(__val) => __val,
665                                        _serde::__private::Err(__err) => {
666                                            return _serde::__private::Err(__err);
667                                        }
668                                    },
669                                );
670                            }
671                            __Field::m_diffuseColor => {
672                                #[cfg(
673                                    any(feature = "strict", feature = "ignore_duplicates")
674                                )]
675                                if _serde::__private::Option::is_some(&m_diffuseColor) {
676                                    #[cfg(feature = "ignore_duplicates")]
677                                    {
678                                        __A::skip_value(&mut __map)?;
679                                        continue;
680                                    }
681                                    #[cfg(feature = "strict")]
682                                    return _serde::__private::Err(
683                                        <__A::Error as _serde::de::Error>::duplicate_field(
684                                            "diffuseColor",
685                                        ),
686                                    );
687                                }
688                                m_diffuseColor = _serde::__private::Some(
689                                    match __A::next_value::<Vector4>(&mut __map) {
690                                        _serde::__private::Ok(__val) => __val,
691                                        _serde::__private::Err(__err) => {
692                                            return _serde::__private::Err(__err);
693                                        }
694                                    },
695                                );
696                            }
697                            __Field::m_ambientColor => {
698                                #[cfg(
699                                    any(feature = "strict", feature = "ignore_duplicates")
700                                )]
701                                if _serde::__private::Option::is_some(&m_ambientColor) {
702                                    #[cfg(feature = "ignore_duplicates")]
703                                    {
704                                        __A::skip_value(&mut __map)?;
705                                        continue;
706                                    }
707                                    #[cfg(feature = "strict")]
708                                    return _serde::__private::Err(
709                                        <__A::Error as _serde::de::Error>::duplicate_field(
710                                            "ambientColor",
711                                        ),
712                                    );
713                                }
714                                m_ambientColor = _serde::__private::Some(
715                                    match __A::next_value::<Vector4>(&mut __map) {
716                                        _serde::__private::Ok(__val) => __val,
717                                        _serde::__private::Err(__err) => {
718                                            return _serde::__private::Err(__err);
719                                        }
720                                    },
721                                );
722                            }
723                            __Field::m_specularColor => {
724                                #[cfg(
725                                    any(feature = "strict", feature = "ignore_duplicates")
726                                )]
727                                if _serde::__private::Option::is_some(&m_specularColor) {
728                                    #[cfg(feature = "ignore_duplicates")]
729                                    {
730                                        __A::skip_value(&mut __map)?;
731                                        continue;
732                                    }
733                                    #[cfg(feature = "strict")]
734                                    return _serde::__private::Err(
735                                        <__A::Error as _serde::de::Error>::duplicate_field(
736                                            "specularColor",
737                                        ),
738                                    );
739                                }
740                                m_specularColor = _serde::__private::Some(
741                                    match __A::next_value::<Vector4>(&mut __map) {
742                                        _serde::__private::Ok(__val) => __val,
743                                        _serde::__private::Err(__err) => {
744                                            return _serde::__private::Err(__err);
745                                        }
746                                    },
747                                );
748                            }
749                            __Field::m_emissiveColor => {
750                                #[cfg(
751                                    any(feature = "strict", feature = "ignore_duplicates")
752                                )]
753                                if _serde::__private::Option::is_some(&m_emissiveColor) {
754                                    #[cfg(feature = "ignore_duplicates")]
755                                    {
756                                        __A::skip_value(&mut __map)?;
757                                        continue;
758                                    }
759                                    #[cfg(feature = "strict")]
760                                    return _serde::__private::Err(
761                                        <__A::Error as _serde::de::Error>::duplicate_field(
762                                            "emissiveColor",
763                                        ),
764                                    );
765                                }
766                                m_emissiveColor = _serde::__private::Some(
767                                    match __A::next_value::<Vector4>(&mut __map) {
768                                        _serde::__private::Ok(__val) => __val,
769                                        _serde::__private::Err(__err) => {
770                                            return _serde::__private::Err(__err);
771                                        }
772                                    },
773                                );
774                            }
775                            __Field::m_subMaterials => {
776                                #[cfg(
777                                    any(feature = "strict", feature = "ignore_duplicates")
778                                )]
779                                if _serde::__private::Option::is_some(&m_subMaterials) {
780                                    #[cfg(feature = "ignore_duplicates")]
781                                    {
782                                        __A::skip_value(&mut __map)?;
783                                        continue;
784                                    }
785                                    #[cfg(feature = "strict")]
786                                    return _serde::__private::Err(
787                                        <__A::Error as _serde::de::Error>::duplicate_field(
788                                            "subMaterials",
789                                        ),
790                                    );
791                                }
792                                m_subMaterials = _serde::__private::Some(
793                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
794                                        _serde::__private::Ok(__val) => __val,
795                                        _serde::__private::Err(__err) => {
796                                            return _serde::__private::Err(__err);
797                                        }
798                                    },
799                                );
800                            }
801                            __Field::m_extraData => {
802                                #[cfg(
803                                    any(feature = "strict", feature = "ignore_duplicates")
804                                )]
805                                if _serde::__private::Option::is_some(&m_extraData) {
806                                    #[cfg(feature = "ignore_duplicates")]
807                                    {
808                                        __A::skip_value(&mut __map)?;
809                                        continue;
810                                    }
811                                    #[cfg(feature = "strict")]
812                                    return _serde::__private::Err(
813                                        <__A::Error as _serde::de::Error>::duplicate_field(
814                                            "extraData",
815                                        ),
816                                    );
817                                }
818                                m_extraData = _serde::__private::Some(
819                                    match __A::next_value::<Pointer>(&mut __map) {
820                                        _serde::__private::Ok(__val) => __val,
821                                        _serde::__private::Err(__err) => {
822                                            return _serde::__private::Err(__err);
823                                        }
824                                    },
825                                );
826                            }
827                            __Field::m_properties => {
828                                #[cfg(
829                                    any(feature = "strict", feature = "ignore_duplicates")
830                                )]
831                                if _serde::__private::Option::is_some(&m_properties) {
832                                    #[cfg(feature = "ignore_duplicates")]
833                                    {
834                                        __A::skip_value(&mut __map)?;
835                                        continue;
836                                    }
837                                    #[cfg(feature = "strict")]
838                                    return _serde::__private::Err(
839                                        <__A::Error as _serde::de::Error>::duplicate_field(
840                                            "properties",
841                                        ),
842                                    );
843                                }
844                                m_properties = _serde::__private::Some(
845                                    match __A::next_value::<
846                                        Vec<hkxMaterialProperty>,
847                                    >(&mut __map) {
848                                        _serde::__private::Ok(__val) => __val,
849                                        _serde::__private::Err(__err) => {
850                                            return _serde::__private::Err(__err);
851                                        }
852                                    },
853                                );
854                            }
855                            _ => __A::skip_value(&mut __map)?,
856                        }
857                    }
858                    let m_attributeGroups = match m_attributeGroups {
859                        _serde::__private::Some(__field) => __field,
860                        _serde::__private::None => {
861                            #[cfg(feature = "strict")]
862                            return _serde::__private::Err(
863                                <__A::Error as _serde::de::Error>::missing_field(
864                                    "attributeGroups",
865                                ),
866                            );
867                            #[cfg(not(feature = "strict"))] Default::default()
868                        }
869                    };
870                    let m_name = match m_name {
871                        _serde::__private::Some(__field) => __field,
872                        _serde::__private::None => {
873                            #[cfg(feature = "strict")]
874                            return _serde::__private::Err(
875                                <__A::Error as _serde::de::Error>::missing_field("name"),
876                            );
877                            #[cfg(not(feature = "strict"))] Default::default()
878                        }
879                    };
880                    let m_stages = match m_stages {
881                        _serde::__private::Some(__field) => __field,
882                        _serde::__private::None => {
883                            #[cfg(feature = "strict")]
884                            return _serde::__private::Err(
885                                <__A::Error as _serde::de::Error>::missing_field("stages"),
886                            );
887                            #[cfg(not(feature = "strict"))] Default::default()
888                        }
889                    };
890                    let m_diffuseColor = match m_diffuseColor {
891                        _serde::__private::Some(__field) => __field,
892                        _serde::__private::None => {
893                            #[cfg(feature = "strict")]
894                            return _serde::__private::Err(
895                                <__A::Error as _serde::de::Error>::missing_field(
896                                    "diffuseColor",
897                                ),
898                            );
899                            #[cfg(not(feature = "strict"))] Default::default()
900                        }
901                    };
902                    let m_ambientColor = match m_ambientColor {
903                        _serde::__private::Some(__field) => __field,
904                        _serde::__private::None => {
905                            #[cfg(feature = "strict")]
906                            return _serde::__private::Err(
907                                <__A::Error as _serde::de::Error>::missing_field(
908                                    "ambientColor",
909                                ),
910                            );
911                            #[cfg(not(feature = "strict"))] Default::default()
912                        }
913                    };
914                    let m_specularColor = match m_specularColor {
915                        _serde::__private::Some(__field) => __field,
916                        _serde::__private::None => {
917                            #[cfg(feature = "strict")]
918                            return _serde::__private::Err(
919                                <__A::Error as _serde::de::Error>::missing_field(
920                                    "specularColor",
921                                ),
922                            );
923                            #[cfg(not(feature = "strict"))] Default::default()
924                        }
925                    };
926                    let m_emissiveColor = match m_emissiveColor {
927                        _serde::__private::Some(__field) => __field,
928                        _serde::__private::None => {
929                            #[cfg(feature = "strict")]
930                            return _serde::__private::Err(
931                                <__A::Error as _serde::de::Error>::missing_field(
932                                    "emissiveColor",
933                                ),
934                            );
935                            #[cfg(not(feature = "strict"))] Default::default()
936                        }
937                    };
938                    let m_subMaterials = match m_subMaterials {
939                        _serde::__private::Some(__field) => __field,
940                        _serde::__private::None => {
941                            #[cfg(feature = "strict")]
942                            return _serde::__private::Err(
943                                <__A::Error as _serde::de::Error>::missing_field(
944                                    "subMaterials",
945                                ),
946                            );
947                            #[cfg(not(feature = "strict"))] Default::default()
948                        }
949                    };
950                    let m_extraData = match m_extraData {
951                        _serde::__private::Some(__field) => __field,
952                        _serde::__private::None => {
953                            #[cfg(feature = "strict")]
954                            return _serde::__private::Err(
955                                <__A::Error as _serde::de::Error>::missing_field(
956                                    "extraData",
957                                ),
958                            );
959                            #[cfg(not(feature = "strict"))] Default::default()
960                        }
961                    };
962                    let m_properties = match m_properties {
963                        _serde::__private::Some(__field) => __field,
964                        _serde::__private::None => {
965                            #[cfg(feature = "strict")]
966                            return _serde::__private::Err(
967                                <__A::Error as _serde::de::Error>::missing_field(
968                                    "properties",
969                                ),
970                            );
971                            #[cfg(not(feature = "strict"))] Default::default()
972                        }
973                    };
974                    let __ptr = None;
975                    let parent = hkBaseObject { __ptr };
976                    let parent = hkReferencedObject {
977                        __ptr,
978                        parent,
979                        ..Default::default()
980                    };
981                    let parent = hkxAttributeHolder {
982                        __ptr,
983                        parent,
984                        m_attributeGroups,
985                    };
986                    let __ptr = __A::class_ptr(&mut __map);
987                    _serde::__private::Ok(hkxMaterial {
988                        __ptr,
989                        parent,
990                        m_name,
991                        m_stages,
992                        m_diffuseColor,
993                        m_ambientColor,
994                        m_specularColor,
995                        m_emissiveColor,
996                        m_subMaterials,
997                        m_extraData,
998                        m_properties,
999                    })
1000                }
1001            }
1002            const FIELDS: &[&str] = &[
1003                "name",
1004                "stages",
1005                "diffuseColor",
1006                "ambientColor",
1007                "specularColor",
1008                "emissiveColor",
1009                "subMaterials",
1010                "extraData",
1011                "properties",
1012            ];
1013            _serde::Deserializer::deserialize_struct(
1014                deserializer,
1015                "hkxMaterial",
1016                FIELDS,
1017                __hkxMaterialVisitor {
1018                    marker: _serde::__private::PhantomData::<hkxMaterial>,
1019                    lifetime: _serde::__private::PhantomData,
1020                },
1021            )
1022        }
1023    }
1024};
1025/// # C++ Info
1026/// - name: `TextureType`(ctype: `hkEnum<TextureType, hkInt32>`)
1027#[allow(non_upper_case_globals, non_snake_case)]
1028#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1029#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1030#[derive(
1031    Debug,
1032    Clone,
1033    Default,
1034    PartialEq,
1035    Eq,
1036    PartialOrd,
1037    Ord,
1038    num_derive::ToPrimitive,
1039    num_derive::FromPrimitive,
1040)]
1041pub enum TextureType {
1042    #[default]
1043    TEX_UNKNOWN = 0isize,
1044    TEX_DIFFUSE = 1isize,
1045    TEX_REFLECTION = 2isize,
1046    TEX_BUMP = 3isize,
1047    TEX_NORMAL = 4isize,
1048    TEX_DISPLACEMENT = 5isize,
1049    TEX_SPECULAR = 6isize,
1050    TEX_SPECULARANDGLOSS = 7isize,
1051    TEX_OPACITY = 8isize,
1052    TEX_EMISSIVE = 9isize,
1053    TEX_REFRACTION = 10isize,
1054    TEX_GLOSS = 11isize,
1055    TEX_NOTEXPORTED = 12isize,
1056}
1057const _: () = {
1058    use havok_serde as __serde;
1059    impl __serde::Serialize for TextureType {
1060        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1061        where
1062            S: __serde::ser::Serializer,
1063        {
1064            let mut __serializer = __serializer.serialize_enum_flags()?;
1065            match self {
1066                Self::TEX_UNKNOWN => __serializer.serialize_field("TEX_UNKNOWN", &0u64),
1067                Self::TEX_DIFFUSE => __serializer.serialize_field("TEX_DIFFUSE", &1u64),
1068                Self::TEX_REFLECTION => {
1069                    __serializer.serialize_field("TEX_REFLECTION", &2u64)
1070                }
1071                Self::TEX_BUMP => __serializer.serialize_field("TEX_BUMP", &3u64),
1072                Self::TEX_NORMAL => __serializer.serialize_field("TEX_NORMAL", &4u64),
1073                Self::TEX_DISPLACEMENT => {
1074                    __serializer.serialize_field("TEX_DISPLACEMENT", &5u64)
1075                }
1076                Self::TEX_SPECULAR => __serializer.serialize_field("TEX_SPECULAR", &6u64),
1077                Self::TEX_SPECULARANDGLOSS => {
1078                    __serializer.serialize_field("TEX_SPECULARANDGLOSS", &7u64)
1079                }
1080                Self::TEX_OPACITY => __serializer.serialize_field("TEX_OPACITY", &8u64),
1081                Self::TEX_EMISSIVE => __serializer.serialize_field("TEX_EMISSIVE", &9u64),
1082                Self::TEX_REFRACTION => {
1083                    __serializer.serialize_field("TEX_REFRACTION", &10u64)
1084                }
1085                Self::TEX_GLOSS => __serializer.serialize_field("TEX_GLOSS", &11u64),
1086                Self::TEX_NOTEXPORTED => {
1087                    __serializer.serialize_field("TEX_NOTEXPORTED", &12u64)
1088                }
1089            }?;
1090            use num_traits::ToPrimitive as _;
1091            let num = self
1092                .to_i32()
1093                .ok_or(S::Error::custom("Failed enum TextureType to_i32"))?;
1094            __serializer.serialize_bits(&num)?;
1095            __serializer.end()
1096        }
1097    }
1098};
1099#[doc(hidden)]
1100#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1101const _: () = {
1102    #[allow(unused_extern_crates, clippy::useless_attribute)]
1103    extern crate havok_serde as _serde;
1104    #[automatically_derived]
1105    impl<'de> _serde::Deserialize<'de> for TextureType {
1106        fn deserialize<__D>(
1107            __deserializer: __D,
1108        ) -> _serde::__private::Result<Self, __D::Error>
1109        where
1110            __D: _serde::Deserializer<'de>,
1111        {
1112            #[allow(non_camel_case_types)]
1113            #[doc(hidden)]
1114            enum __Field {
1115                __field0,
1116                __field1,
1117                __field2,
1118                __field3,
1119                __field4,
1120                __field5,
1121                __field6,
1122                __field7,
1123                __field8,
1124                __field9,
1125                __field10,
1126                __field11,
1127                __field12,
1128            }
1129            #[doc(hidden)]
1130            struct __FieldVisitor;
1131            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1132                type Value = __Field;
1133                fn expecting(
1134                    &self,
1135                    __formatter: &mut _serde::__private::Formatter,
1136                ) -> _serde::__private::fmt::Result {
1137                    _serde::__private::Formatter::write_str(
1138                        __formatter,
1139                        "variant identifier",
1140                    )
1141                }
1142                fn visit_int32<__E>(
1143                    self,
1144                    __value: i32,
1145                ) -> _serde::__private::Result<Self::Value, __E>
1146                where
1147                    __E: _serde::de::Error,
1148                {
1149                    match __value {
1150                        0i32 => _serde::__private::Ok(__Field::__field0),
1151                        1i32 => _serde::__private::Ok(__Field::__field1),
1152                        2i32 => _serde::__private::Ok(__Field::__field2),
1153                        3i32 => _serde::__private::Ok(__Field::__field3),
1154                        4i32 => _serde::__private::Ok(__Field::__field4),
1155                        5i32 => _serde::__private::Ok(__Field::__field5),
1156                        6i32 => _serde::__private::Ok(__Field::__field6),
1157                        7i32 => _serde::__private::Ok(__Field::__field7),
1158                        8i32 => _serde::__private::Ok(__Field::__field8),
1159                        9i32 => _serde::__private::Ok(__Field::__field9),
1160                        10i32 => _serde::__private::Ok(__Field::__field10),
1161                        11i32 => _serde::__private::Ok(__Field::__field11),
1162                        12i32 => _serde::__private::Ok(__Field::__field12),
1163                        _ => {
1164                            _serde::__private::Err(
1165                                _serde::de::Error::invalid_value(
1166                                    _serde::de::Unexpected::Int32(__value),
1167                                    &"value(i32) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12",
1168                                ),
1169                            )
1170                        }
1171                    }
1172                }
1173                fn visit_stringptr<__E>(
1174                    self,
1175                    __value: StringPtr<'de>,
1176                ) -> _serde::__private::Result<Self::Value, __E>
1177                where
1178                    __E: _serde::de::Error,
1179                {
1180                    if let Some(__value) = __value.into_inner() {
1181                        match __value.as_ref() {
1182                            v if v == "0" || v.eq_ignore_ascii_case("TEX_UNKNOWN") => {
1183                                _serde::__private::Ok(__Field::__field0)
1184                            }
1185                            v if v == "1" || v.eq_ignore_ascii_case("TEX_DIFFUSE") => {
1186                                _serde::__private::Ok(__Field::__field1)
1187                            }
1188                            v if v == "2" || v.eq_ignore_ascii_case("TEX_REFLECTION") => {
1189                                _serde::__private::Ok(__Field::__field2)
1190                            }
1191                            v if v == "3" || v.eq_ignore_ascii_case("TEX_BUMP") => {
1192                                _serde::__private::Ok(__Field::__field3)
1193                            }
1194                            v if v == "4" || v.eq_ignore_ascii_case("TEX_NORMAL") => {
1195                                _serde::__private::Ok(__Field::__field4)
1196                            }
1197                            v if v == "5"
1198                                || v.eq_ignore_ascii_case("TEX_DISPLACEMENT") => {
1199                                _serde::__private::Ok(__Field::__field5)
1200                            }
1201                            v if v == "6" || v.eq_ignore_ascii_case("TEX_SPECULAR") => {
1202                                _serde::__private::Ok(__Field::__field6)
1203                            }
1204                            v if v == "7"
1205                                || v.eq_ignore_ascii_case("TEX_SPECULARANDGLOSS") => {
1206                                _serde::__private::Ok(__Field::__field7)
1207                            }
1208                            v if v == "8" || v.eq_ignore_ascii_case("TEX_OPACITY") => {
1209                                _serde::__private::Ok(__Field::__field8)
1210                            }
1211                            v if v == "9" || v.eq_ignore_ascii_case("TEX_EMISSIVE") => {
1212                                _serde::__private::Ok(__Field::__field9)
1213                            }
1214                            v if v == "10"
1215                                || v.eq_ignore_ascii_case("TEX_REFRACTION") => {
1216                                _serde::__private::Ok(__Field::__field10)
1217                            }
1218                            v if v == "11" || v.eq_ignore_ascii_case("TEX_GLOSS") => {
1219                                _serde::__private::Ok(__Field::__field11)
1220                            }
1221                            v if v == "12"
1222                                || v.eq_ignore_ascii_case("TEX_NOTEXPORTED") => {
1223                                _serde::__private::Ok(__Field::__field12)
1224                            }
1225                            _ => {
1226                                _serde::__private::Err(
1227                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1228                                )
1229                            }
1230                        }
1231                    } else {
1232                        _serde::__private::Err(
1233                            _serde::de::Error::unknown_variant("None", VARIANTS),
1234                        )
1235                    }
1236                }
1237            }
1238            impl<'de> _serde::Deserialize<'de> for __Field {
1239                #[inline]
1240                fn deserialize<__D>(
1241                    __deserializer: __D,
1242                ) -> _serde::__private::Result<Self, __D::Error>
1243                where
1244                    __D: _serde::Deserializer<'de>,
1245                {
1246                    _serde::Deserializer::deserialize_identifier(
1247                        __deserializer,
1248                        _serde::de::ReadEnumSize::Int32,
1249                        __FieldVisitor,
1250                    )
1251                }
1252            }
1253            #[doc(hidden)]
1254            struct __Visitor<'de> {
1255                marker: _serde::__private::PhantomData<TextureType>,
1256                lifetime: _serde::__private::PhantomData<&'de ()>,
1257            }
1258            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1259                type Value = TextureType;
1260                fn expecting(
1261                    &self,
1262                    __formatter: &mut _serde::__private::Formatter,
1263                ) -> _serde::__private::fmt::Result {
1264                    _serde::__private::Formatter::write_str(
1265                        __formatter,
1266                        "enum TextureType",
1267                    )
1268                }
1269                fn visit_enum<__A>(
1270                    self,
1271                    __data: __A,
1272                ) -> _serde::__private::Result<Self::Value, __A::Error>
1273                where
1274                    __A: _serde::de::EnumAccess<'de>,
1275                {
1276                    match _serde::de::EnumAccess::variant(__data)? {
1277                        (__Field::__field0, __variant) => {
1278                            _serde::de::VariantAccess::unit_variant(__variant)?;
1279                            _serde::__private::Ok(TextureType::TEX_UNKNOWN)
1280                        }
1281                        (__Field::__field1, __variant) => {
1282                            _serde::de::VariantAccess::unit_variant(__variant)?;
1283                            _serde::__private::Ok(TextureType::TEX_DIFFUSE)
1284                        }
1285                        (__Field::__field2, __variant) => {
1286                            _serde::de::VariantAccess::unit_variant(__variant)?;
1287                            _serde::__private::Ok(TextureType::TEX_REFLECTION)
1288                        }
1289                        (__Field::__field3, __variant) => {
1290                            _serde::de::VariantAccess::unit_variant(__variant)?;
1291                            _serde::__private::Ok(TextureType::TEX_BUMP)
1292                        }
1293                        (__Field::__field4, __variant) => {
1294                            _serde::de::VariantAccess::unit_variant(__variant)?;
1295                            _serde::__private::Ok(TextureType::TEX_NORMAL)
1296                        }
1297                        (__Field::__field5, __variant) => {
1298                            _serde::de::VariantAccess::unit_variant(__variant)?;
1299                            _serde::__private::Ok(TextureType::TEX_DISPLACEMENT)
1300                        }
1301                        (__Field::__field6, __variant) => {
1302                            _serde::de::VariantAccess::unit_variant(__variant)?;
1303                            _serde::__private::Ok(TextureType::TEX_SPECULAR)
1304                        }
1305                        (__Field::__field7, __variant) => {
1306                            _serde::de::VariantAccess::unit_variant(__variant)?;
1307                            _serde::__private::Ok(TextureType::TEX_SPECULARANDGLOSS)
1308                        }
1309                        (__Field::__field8, __variant) => {
1310                            _serde::de::VariantAccess::unit_variant(__variant)?;
1311                            _serde::__private::Ok(TextureType::TEX_OPACITY)
1312                        }
1313                        (__Field::__field9, __variant) => {
1314                            _serde::de::VariantAccess::unit_variant(__variant)?;
1315                            _serde::__private::Ok(TextureType::TEX_EMISSIVE)
1316                        }
1317                        (__Field::__field10, __variant) => {
1318                            _serde::de::VariantAccess::unit_variant(__variant)?;
1319                            _serde::__private::Ok(TextureType::TEX_REFRACTION)
1320                        }
1321                        (__Field::__field11, __variant) => {
1322                            _serde::de::VariantAccess::unit_variant(__variant)?;
1323                            _serde::__private::Ok(TextureType::TEX_GLOSS)
1324                        }
1325                        (__Field::__field12, __variant) => {
1326                            _serde::de::VariantAccess::unit_variant(__variant)?;
1327                            _serde::__private::Ok(TextureType::TEX_NOTEXPORTED)
1328                        }
1329                    }
1330                }
1331            }
1332            #[doc(hidden)]
1333            const VARIANTS: &'static [&'static str] = &[
1334                "TEX_UNKNOWN",
1335                "TEX_DIFFUSE",
1336                "TEX_REFLECTION",
1337                "TEX_BUMP",
1338                "TEX_NORMAL",
1339                "TEX_DISPLACEMENT",
1340                "TEX_SPECULAR",
1341                "TEX_SPECULARANDGLOSS",
1342                "TEX_OPACITY",
1343                "TEX_EMISSIVE",
1344                "TEX_REFRACTION",
1345                "TEX_GLOSS",
1346                "TEX_NOTEXPORTED",
1347            ];
1348            _serde::Deserializer::deserialize_enum(
1349                __deserializer,
1350                "TextureType",
1351                VARIANTS,
1352                __Visitor {
1353                    marker: _serde::__private::PhantomData::<TextureType>,
1354                    lifetime: _serde::__private::PhantomData,
1355                },
1356            )
1357        }
1358    }
1359};