havok_classes/generated/
hkVertexFormatElement_.rs

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

havok_classes/generated/
hkVertexFormatElement_.rs
