havok_classes/generated/
hkxMaterialEffect_.rs

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

havok_classes/generated/
hkxMaterialEffect_.rs
