havok_classes/generated/
hkxMaterialShader_.rs

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

havok_classes/generated/
hkxMaterialShader_.rs
