havok_classes/generated/
hkxVertexDescriptionElementDecl_.rs

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