havok_classes/generated/
hkxVertexBufferVertexData_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkxVertexBufferVertexData`
5/// - version: `0`
6/// - signature: `0xd72b6fd0`
7/// - size: ` 84`(x86)/`104`(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 hkxVertexBufferVertexData {
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: `vectorData`(ctype: `hkArray<hkVector4>`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 12`(x86)/` 16`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "vectorData"))]
31    #[cfg_attr(feature = "serde", serde(rename = "vectorData"))]
32    pub m_vectorData: Vec<Vector4>,
33    /// # C++ Info
34    /// - name: `floatData`(ctype: `hkArray<hkReal>`)
35    /// - offset: ` 12`(x86)/` 16`(x86_64)
36    /// - type_size: ` 12`(x86)/` 16`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "floatData"))]
38    #[cfg_attr(feature = "serde", serde(rename = "floatData"))]
39    pub m_floatData: Vec<f32>,
40    /// # C++ Info
41    /// - name: `uint32Data`(ctype: `hkArray<hkUint32>`)
42    /// - offset: ` 24`(x86)/` 32`(x86_64)
43    /// - type_size: ` 12`(x86)/` 16`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "uint32Data"))]
45    #[cfg_attr(feature = "serde", serde(rename = "uint32Data"))]
46    pub m_uint32Data: Vec<u32>,
47    /// # C++ Info
48    /// - name: `uint16Data`(ctype: `hkArray<hkUint16>`)
49    /// - offset: ` 36`(x86)/` 48`(x86_64)
50    /// - type_size: ` 12`(x86)/` 16`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "uint16Data"))]
52    #[cfg_attr(feature = "serde", serde(rename = "uint16Data"))]
53    pub m_uint16Data: Vec<u16>,
54    /// # C++ Info
55    /// - name: `uint8Data`(ctype: `hkArray<hkUint8>`)
56    /// - offset: ` 48`(x86)/` 64`(x86_64)
57    /// - type_size: ` 12`(x86)/` 16`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "uint8Data"))]
59    #[cfg_attr(feature = "serde", serde(rename = "uint8Data"))]
60    pub m_uint8Data: Vec<u8>,
61    /// # C++ Info
62    /// - name: `numVerts`(ctype: `hkUint32`)
63    /// - offset: ` 60`(x86)/` 80`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "numVerts"))]
66    #[cfg_attr(feature = "serde", serde(rename = "numVerts"))]
67    pub m_numVerts: u32,
68    /// # C++ Info
69    /// - name: `vectorStride`(ctype: `hkUint32`)
70    /// - offset: ` 64`(x86)/` 84`(x86_64)
71    /// - type_size: `  4`(x86)/`  4`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "vectorStride"))]
73    #[cfg_attr(feature = "serde", serde(rename = "vectorStride"))]
74    pub m_vectorStride: u32,
75    /// # C++ Info
76    /// - name: `floatStride`(ctype: `hkUint32`)
77    /// - offset: ` 68`(x86)/` 88`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "floatStride"))]
80    #[cfg_attr(feature = "serde", serde(rename = "floatStride"))]
81    pub m_floatStride: u32,
82    /// # C++ Info
83    /// - name: `uint32Stride`(ctype: `hkUint32`)
84    /// - offset: ` 72`(x86)/` 92`(x86_64)
85    /// - type_size: `  4`(x86)/`  4`(x86_64)
86    #[cfg_attr(feature = "json_schema", schemars(rename = "uint32Stride"))]
87    #[cfg_attr(feature = "serde", serde(rename = "uint32Stride"))]
88    pub m_uint32Stride: u32,
89    /// # C++ Info
90    /// - name: `uint16Stride`(ctype: `hkUint32`)
91    /// - offset: ` 76`(x86)/` 96`(x86_64)
92    /// - type_size: `  4`(x86)/`  4`(x86_64)
93    #[cfg_attr(feature = "json_schema", schemars(rename = "uint16Stride"))]
94    #[cfg_attr(feature = "serde", serde(rename = "uint16Stride"))]
95    pub m_uint16Stride: u32,
96    /// # C++ Info
97    /// - name: `uint8Stride`(ctype: `hkUint32`)
98    /// - offset: ` 80`(x86)/`100`(x86_64)
99    /// - type_size: `  4`(x86)/`  4`(x86_64)
100    #[cfg_attr(feature = "json_schema", schemars(rename = "uint8Stride"))]
101    #[cfg_attr(feature = "serde", serde(rename = "uint8Stride"))]
102    pub m_uint8Stride: u32,
103}
104const _: () = {
105    use havok_serde as _serde;
106    impl _serde::HavokClass for hkxVertexBufferVertexData {
107        #[inline]
108        fn name(&self) -> &'static str {
109            "hkxVertexBufferVertexData"
110        }
111        #[inline]
112        fn signature(&self) -> _serde::__private::Signature {
113            _serde::__private::Signature::new(0xd72b6fd0)
114        }
115        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
116        fn deps_indexes(&self) -> Vec<usize> {
117            let mut v = Vec::new();
118            v
119        }
120    }
121    impl _serde::Serialize for hkxVertexBufferVertexData {
122        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
123        where
124            S: _serde::ser::Serializer,
125        {
126            let class_meta = self
127                .__ptr
128                .map(|name| (name, _serde::__private::Signature::new(0xd72b6fd0)));
129            let mut serializer = __serializer
130                .serialize_struct(
131                    "hkxVertexBufferVertexData",
132                    class_meta,
133                    (84u64, 104u64),
134                )?;
135            serializer
136                .serialize_array_field(
137                    "vectorData",
138                    &self.m_vectorData,
139                    TypeSize::NonPtr,
140                )?;
141            serializer
142                .serialize_array_field(
143                    "floatData",
144                    &self.m_floatData,
145                    TypeSize::NonPtr,
146                )?;
147            serializer
148                .serialize_array_field(
149                    "uint32Data",
150                    &self.m_uint32Data,
151                    TypeSize::NonPtr,
152                )?;
153            serializer
154                .serialize_array_field(
155                    "uint16Data",
156                    &self.m_uint16Data,
157                    TypeSize::NonPtr,
158                )?;
159            serializer
160                .serialize_array_field(
161                    "uint8Data",
162                    &self.m_uint8Data,
163                    TypeSize::NonPtr,
164                )?;
165            serializer.serialize_field("numVerts", &self.m_numVerts)?;
166            serializer.serialize_field("vectorStride", &self.m_vectorStride)?;
167            serializer.serialize_field("floatStride", &self.m_floatStride)?;
168            serializer.serialize_field("uint32Stride", &self.m_uint32Stride)?;
169            serializer.serialize_field("uint16Stride", &self.m_uint16Stride)?;
170            serializer.serialize_field("uint8Stride", &self.m_uint8Stride)?;
171            serializer.end()
172        }
173    }
174};
175#[doc(hidden)]
176#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
177const _: () = {
178    use havok_serde as _serde;
179    #[automatically_derived]
180    impl<'de> _serde::Deserialize<'de> for hkxVertexBufferVertexData {
181        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
182        where
183            __D: _serde::Deserializer<'de>,
184        {
185            #[allow(non_camel_case_types)]
186            enum __Field {
187                m_vectorData,
188                m_floatData,
189                m_uint32Data,
190                m_uint16Data,
191                m_uint8Data,
192                m_numVerts,
193                m_vectorStride,
194                m_floatStride,
195                m_uint32Stride,
196                m_uint16Stride,
197                m_uint8Stride,
198                __ignore,
199            }
200            struct __FieldVisitor;
201            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
202                type Value = __Field;
203                fn expecting(
204                    &self,
205                    __formatter: &mut core::fmt::Formatter,
206                ) -> core::fmt::Result {
207                    core::fmt::Formatter::write_str(__formatter, "field identifier")
208                }
209                /// Intended for use in XML.
210                #[allow(clippy::match_single_binding)]
211                #[allow(clippy::reversed_empty_ranges)]
212                #[allow(clippy::single_match)]
213                fn visit_key<__E>(
214                    self,
215                    __value: &str,
216                ) -> core::result::Result<Self::Value, __E>
217                where
218                    __E: _serde::de::Error,
219                {
220                    match __value {
221                        "vectorData" => Ok(__Field::m_vectorData),
222                        "floatData" => Ok(__Field::m_floatData),
223                        "uint32Data" => Ok(__Field::m_uint32Data),
224                        "uint16Data" => Ok(__Field::m_uint16Data),
225                        "uint8Data" => Ok(__Field::m_uint8Data),
226                        "numVerts" => Ok(__Field::m_numVerts),
227                        "vectorStride" => Ok(__Field::m_vectorStride),
228                        "floatStride" => Ok(__Field::m_floatStride),
229                        "uint32Stride" => Ok(__Field::m_uint32Stride),
230                        "uint16Stride" => Ok(__Field::m_uint16Stride),
231                        "uint8Stride" => Ok(__Field::m_uint8Stride),
232                        _ => Ok(__Field::__ignore),
233                    }
234                }
235            }
236            impl<'de> _serde::Deserialize<'de> for __Field {
237                #[inline]
238                fn deserialize<__D>(
239                    __deserializer: __D,
240                ) -> core::result::Result<Self, __D::Error>
241                where
242                    __D: _serde::Deserializer<'de>,
243                {
244                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
245                }
246            }
247            struct __hkxVertexBufferVertexDataVisitor<'de> {
248                marker: _serde::__private::PhantomData<hkxVertexBufferVertexData>,
249                lifetime: _serde::__private::PhantomData<&'de ()>,
250            }
251            #[allow(clippy::match_single_binding)]
252            #[allow(clippy::reversed_empty_ranges)]
253            #[allow(clippy::single_match)]
254            impl<'de> _serde::de::Visitor<'de>
255            for __hkxVertexBufferVertexDataVisitor<'de> {
256                type Value = hkxVertexBufferVertexData;
257                fn expecting(
258                    &self,
259                    __formatter: &mut core::fmt::Formatter,
260                ) -> core::fmt::Result {
261                    core::fmt::Formatter::write_str(
262                        __formatter,
263                        "struct hkxVertexBufferVertexData",
264                    )
265                }
266                fn visit_struct_for_bytes<__A>(
267                    self,
268                    mut __map: __A,
269                ) -> _serde::__private::Result<Self::Value, __A::Error>
270                where
271                    __A: _serde::de::MapAccess<'de>,
272                {
273                    let __ptr = __A::class_ptr(&mut __map);
274                    let mut m_vectorData: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
275                    let mut m_floatData: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
276                    let mut m_uint32Data: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
277                    let mut m_uint16Data: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
278                    let mut m_uint8Data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
279                    let mut m_numVerts: _serde::__private::Option<u32> = _serde::__private::None;
280                    let mut m_vectorStride: _serde::__private::Option<u32> = _serde::__private::None;
281                    let mut m_floatStride: _serde::__private::Option<u32> = _serde::__private::None;
282                    let mut m_uint32Stride: _serde::__private::Option<u32> = _serde::__private::None;
283                    let mut m_uint16Stride: _serde::__private::Option<u32> = _serde::__private::None;
284                    let mut m_uint8Stride: _serde::__private::Option<u32> = _serde::__private::None;
285                    for i in 0..11usize {
286                        match i {
287                            0usize => {
288                                if _serde::__private::Option::is_some(&m_vectorData) {
289                                    return _serde::__private::Err(
290                                        <__A::Error as _serde::de::Error>::duplicate_field(
291                                            "vectorData",
292                                        ),
293                                    );
294                                }
295                                m_vectorData = _serde::__private::Some(
296                                    match __A::next_value::<Vec<Vector4>>(&mut __map) {
297                                        _serde::__private::Ok(__val) => __val,
298                                        _serde::__private::Err(__err) => {
299                                            return _serde::__private::Err(__err);
300                                        }
301                                    },
302                                );
303                            }
304                            1usize => {
305                                if _serde::__private::Option::is_some(&m_floatData) {
306                                    return _serde::__private::Err(
307                                        <__A::Error as _serde::de::Error>::duplicate_field(
308                                            "floatData",
309                                        ),
310                                    );
311                                }
312                                m_floatData = _serde::__private::Some(
313                                    match __A::next_value::<Vec<f32>>(&mut __map) {
314                                        _serde::__private::Ok(__val) => __val,
315                                        _serde::__private::Err(__err) => {
316                                            return _serde::__private::Err(__err);
317                                        }
318                                    },
319                                );
320                            }
321                            2usize => {
322                                if _serde::__private::Option::is_some(&m_uint32Data) {
323                                    return _serde::__private::Err(
324                                        <__A::Error as _serde::de::Error>::duplicate_field(
325                                            "uint32Data",
326                                        ),
327                                    );
328                                }
329                                m_uint32Data = _serde::__private::Some(
330                                    match __A::next_value::<Vec<u32>>(&mut __map) {
331                                        _serde::__private::Ok(__val) => __val,
332                                        _serde::__private::Err(__err) => {
333                                            return _serde::__private::Err(__err);
334                                        }
335                                    },
336                                );
337                            }
338                            3usize => {
339                                if _serde::__private::Option::is_some(&m_uint16Data) {
340                                    return _serde::__private::Err(
341                                        <__A::Error as _serde::de::Error>::duplicate_field(
342                                            "uint16Data",
343                                        ),
344                                    );
345                                }
346                                m_uint16Data = _serde::__private::Some(
347                                    match __A::next_value::<Vec<u16>>(&mut __map) {
348                                        _serde::__private::Ok(__val) => __val,
349                                        _serde::__private::Err(__err) => {
350                                            return _serde::__private::Err(__err);
351                                        }
352                                    },
353                                );
354                            }
355                            4usize => {
356                                if _serde::__private::Option::is_some(&m_uint8Data) {
357                                    return _serde::__private::Err(
358                                        <__A::Error as _serde::de::Error>::duplicate_field(
359                                            "uint8Data",
360                                        ),
361                                    );
362                                }
363                                m_uint8Data = _serde::__private::Some(
364                                    match __A::next_value::<Vec<u8>>(&mut __map) {
365                                        _serde::__private::Ok(__val) => __val,
366                                        _serde::__private::Err(__err) => {
367                                            return _serde::__private::Err(__err);
368                                        }
369                                    },
370                                );
371                            }
372                            5usize => {
373                                if _serde::__private::Option::is_some(&m_numVerts) {
374                                    return _serde::__private::Err(
375                                        <__A::Error as _serde::de::Error>::duplicate_field(
376                                            "numVerts",
377                                        ),
378                                    );
379                                }
380                                m_numVerts = _serde::__private::Some(
381                                    match __A::next_value::<u32>(&mut __map) {
382                                        _serde::__private::Ok(__val) => __val,
383                                        _serde::__private::Err(__err) => {
384                                            return _serde::__private::Err(__err);
385                                        }
386                                    },
387                                );
388                            }
389                            6usize => {
390                                if _serde::__private::Option::is_some(&m_vectorStride) {
391                                    return _serde::__private::Err(
392                                        <__A::Error as _serde::de::Error>::duplicate_field(
393                                            "vectorStride",
394                                        ),
395                                    );
396                                }
397                                m_vectorStride = _serde::__private::Some(
398                                    match __A::next_value::<u32>(&mut __map) {
399                                        _serde::__private::Ok(__val) => __val,
400                                        _serde::__private::Err(__err) => {
401                                            return _serde::__private::Err(__err);
402                                        }
403                                    },
404                                );
405                            }
406                            7usize => {
407                                if _serde::__private::Option::is_some(&m_floatStride) {
408                                    return _serde::__private::Err(
409                                        <__A::Error as _serde::de::Error>::duplicate_field(
410                                            "floatStride",
411                                        ),
412                                    );
413                                }
414                                m_floatStride = _serde::__private::Some(
415                                    match __A::next_value::<u32>(&mut __map) {
416                                        _serde::__private::Ok(__val) => __val,
417                                        _serde::__private::Err(__err) => {
418                                            return _serde::__private::Err(__err);
419                                        }
420                                    },
421                                );
422                            }
423                            8usize => {
424                                if _serde::__private::Option::is_some(&m_uint32Stride) {
425                                    return _serde::__private::Err(
426                                        <__A::Error as _serde::de::Error>::duplicate_field(
427                                            "uint32Stride",
428                                        ),
429                                    );
430                                }
431                                m_uint32Stride = _serde::__private::Some(
432                                    match __A::next_value::<u32>(&mut __map) {
433                                        _serde::__private::Ok(__val) => __val,
434                                        _serde::__private::Err(__err) => {
435                                            return _serde::__private::Err(__err);
436                                        }
437                                    },
438                                );
439                            }
440                            9usize => {
441                                if _serde::__private::Option::is_some(&m_uint16Stride) {
442                                    return _serde::__private::Err(
443                                        <__A::Error as _serde::de::Error>::duplicate_field(
444                                            "uint16Stride",
445                                        ),
446                                    );
447                                }
448                                m_uint16Stride = _serde::__private::Some(
449                                    match __A::next_value::<u32>(&mut __map) {
450                                        _serde::__private::Ok(__val) => __val,
451                                        _serde::__private::Err(__err) => {
452                                            return _serde::__private::Err(__err);
453                                        }
454                                    },
455                                );
456                            }
457                            10usize => {
458                                if _serde::__private::Option::is_some(&m_uint8Stride) {
459                                    return _serde::__private::Err(
460                                        <__A::Error as _serde::de::Error>::duplicate_field(
461                                            "uint8Stride",
462                                        ),
463                                    );
464                                }
465                                m_uint8Stride = _serde::__private::Some(
466                                    match __A::next_value::<u32>(&mut __map) {
467                                        _serde::__private::Ok(__val) => __val,
468                                        _serde::__private::Err(__err) => {
469                                            return _serde::__private::Err(__err);
470                                        }
471                                    },
472                                );
473                            }
474                            _ => {}
475                        }
476                    }
477                    let m_vectorData = match m_vectorData {
478                        _serde::__private::Some(__field) => __field,
479                        _serde::__private::None => {
480                            return _serde::__private::Err(
481                                <__A::Error as _serde::de::Error>::missing_field(
482                                    "vectorData",
483                                ),
484                            );
485                        }
486                    };
487                    let m_floatData = match m_floatData {
488                        _serde::__private::Some(__field) => __field,
489                        _serde::__private::None => {
490                            return _serde::__private::Err(
491                                <__A::Error as _serde::de::Error>::missing_field(
492                                    "floatData",
493                                ),
494                            );
495                        }
496                    };
497                    let m_uint32Data = match m_uint32Data {
498                        _serde::__private::Some(__field) => __field,
499                        _serde::__private::None => {
500                            return _serde::__private::Err(
501                                <__A::Error as _serde::de::Error>::missing_field(
502                                    "uint32Data",
503                                ),
504                            );
505                        }
506                    };
507                    let m_uint16Data = match m_uint16Data {
508                        _serde::__private::Some(__field) => __field,
509                        _serde::__private::None => {
510                            return _serde::__private::Err(
511                                <__A::Error as _serde::de::Error>::missing_field(
512                                    "uint16Data",
513                                ),
514                            );
515                        }
516                    };
517                    let m_uint8Data = match m_uint8Data {
518                        _serde::__private::Some(__field) => __field,
519                        _serde::__private::None => {
520                            return _serde::__private::Err(
521                                <__A::Error as _serde::de::Error>::missing_field(
522                                    "uint8Data",
523                                ),
524                            );
525                        }
526                    };
527                    let m_numVerts = match m_numVerts {
528                        _serde::__private::Some(__field) => __field,
529                        _serde::__private::None => {
530                            return _serde::__private::Err(
531                                <__A::Error as _serde::de::Error>::missing_field("numVerts"),
532                            );
533                        }
534                    };
535                    let m_vectorStride = match m_vectorStride {
536                        _serde::__private::Some(__field) => __field,
537                        _serde::__private::None => {
538                            return _serde::__private::Err(
539                                <__A::Error as _serde::de::Error>::missing_field(
540                                    "vectorStride",
541                                ),
542                            );
543                        }
544                    };
545                    let m_floatStride = match m_floatStride {
546                        _serde::__private::Some(__field) => __field,
547                        _serde::__private::None => {
548                            return _serde::__private::Err(
549                                <__A::Error as _serde::de::Error>::missing_field(
550                                    "floatStride",
551                                ),
552                            );
553                        }
554                    };
555                    let m_uint32Stride = match m_uint32Stride {
556                        _serde::__private::Some(__field) => __field,
557                        _serde::__private::None => {
558                            return _serde::__private::Err(
559                                <__A::Error as _serde::de::Error>::missing_field(
560                                    "uint32Stride",
561                                ),
562                            );
563                        }
564                    };
565                    let m_uint16Stride = match m_uint16Stride {
566                        _serde::__private::Some(__field) => __field,
567                        _serde::__private::None => {
568                            return _serde::__private::Err(
569                                <__A::Error as _serde::de::Error>::missing_field(
570                                    "uint16Stride",
571                                ),
572                            );
573                        }
574                    };
575                    let m_uint8Stride = match m_uint8Stride {
576                        _serde::__private::Some(__field) => __field,
577                        _serde::__private::None => {
578                            return _serde::__private::Err(
579                                <__A::Error as _serde::de::Error>::missing_field(
580                                    "uint8Stride",
581                                ),
582                            );
583                        }
584                    };
585                    _serde::__private::Ok(hkxVertexBufferVertexData {
586                        __ptr,
587                        m_vectorData,
588                        m_floatData,
589                        m_uint32Data,
590                        m_uint16Data,
591                        m_uint8Data,
592                        m_numVerts,
593                        m_vectorStride,
594                        m_floatStride,
595                        m_uint32Stride,
596                        m_uint16Stride,
597                        m_uint8Stride,
598                    })
599                }
600                #[allow(clippy::manual_unwrap_or_default)]
601                fn visit_struct<__A>(
602                    self,
603                    mut __map: __A,
604                ) -> _serde::__private::Result<Self::Value, __A::Error>
605                where
606                    __A: _serde::de::MapAccess<'de>,
607                {
608                    let mut m_vectorData: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
609                    let mut m_floatData: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
610                    let mut m_uint32Data: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
611                    let mut m_uint16Data: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
612                    let mut m_uint8Data: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
613                    let mut m_numVerts: _serde::__private::Option<u32> = _serde::__private::None;
614                    let mut m_vectorStride: _serde::__private::Option<u32> = _serde::__private::None;
615                    let mut m_floatStride: _serde::__private::Option<u32> = _serde::__private::None;
616                    let mut m_uint32Stride: _serde::__private::Option<u32> = _serde::__private::None;
617                    let mut m_uint16Stride: _serde::__private::Option<u32> = _serde::__private::None;
618                    let mut m_uint8Stride: _serde::__private::Option<u32> = _serde::__private::None;
619                    while let _serde::__private::Some(__key) = {
620                        __A::next_key::<__Field>(&mut __map)?
621                    } {
622                        match __key {
623                            __Field::m_vectorData => {
624                                #[cfg(
625                                    any(feature = "strict", feature = "ignore_duplicates")
626                                )]
627                                if _serde::__private::Option::is_some(&m_vectorData) {
628                                    #[cfg(feature = "ignore_duplicates")]
629                                    {
630                                        __A::skip_value(&mut __map)?;
631                                        continue;
632                                    }
633                                    #[cfg(feature = "strict")]
634                                    return _serde::__private::Err(
635                                        <__A::Error as _serde::de::Error>::duplicate_field(
636                                            "vectorData",
637                                        ),
638                                    );
639                                }
640                                m_vectorData = _serde::__private::Some(
641                                    match __A::next_value::<Vec<Vector4>>(&mut __map) {
642                                        _serde::__private::Ok(__val) => __val,
643                                        _serde::__private::Err(__err) => {
644                                            return _serde::__private::Err(__err);
645                                        }
646                                    },
647                                );
648                            }
649                            __Field::m_floatData => {
650                                #[cfg(
651                                    any(feature = "strict", feature = "ignore_duplicates")
652                                )]
653                                if _serde::__private::Option::is_some(&m_floatData) {
654                                    #[cfg(feature = "ignore_duplicates")]
655                                    {
656                                        __A::skip_value(&mut __map)?;
657                                        continue;
658                                    }
659                                    #[cfg(feature = "strict")]
660                                    return _serde::__private::Err(
661                                        <__A::Error as _serde::de::Error>::duplicate_field(
662                                            "floatData",
663                                        ),
664                                    );
665                                }
666                                m_floatData = _serde::__private::Some(
667                                    match __A::next_value::<Vec<f32>>(&mut __map) {
668                                        _serde::__private::Ok(__val) => __val,
669                                        _serde::__private::Err(__err) => {
670                                            return _serde::__private::Err(__err);
671                                        }
672                                    },
673                                );
674                            }
675                            __Field::m_uint32Data => {
676                                #[cfg(
677                                    any(feature = "strict", feature = "ignore_duplicates")
678                                )]
679                                if _serde::__private::Option::is_some(&m_uint32Data) {
680                                    #[cfg(feature = "ignore_duplicates")]
681                                    {
682                                        __A::skip_value(&mut __map)?;
683                                        continue;
684                                    }
685                                    #[cfg(feature = "strict")]
686                                    return _serde::__private::Err(
687                                        <__A::Error as _serde::de::Error>::duplicate_field(
688                                            "uint32Data",
689                                        ),
690                                    );
691                                }
692                                m_uint32Data = _serde::__private::Some(
693                                    match __A::next_value::<Vec<u32>>(&mut __map) {
694                                        _serde::__private::Ok(__val) => __val,
695                                        _serde::__private::Err(__err) => {
696                                            return _serde::__private::Err(__err);
697                                        }
698                                    },
699                                );
700                            }
701                            __Field::m_uint16Data => {
702                                #[cfg(
703                                    any(feature = "strict", feature = "ignore_duplicates")
704                                )]
705                                if _serde::__private::Option::is_some(&m_uint16Data) {
706                                    #[cfg(feature = "ignore_duplicates")]
707                                    {
708                                        __A::skip_value(&mut __map)?;
709                                        continue;
710                                    }
711                                    #[cfg(feature = "strict")]
712                                    return _serde::__private::Err(
713                                        <__A::Error as _serde::de::Error>::duplicate_field(
714                                            "uint16Data",
715                                        ),
716                                    );
717                                }
718                                m_uint16Data = _serde::__private::Some(
719                                    match __A::next_value::<Vec<u16>>(&mut __map) {
720                                        _serde::__private::Ok(__val) => __val,
721                                        _serde::__private::Err(__err) => {
722                                            return _serde::__private::Err(__err);
723                                        }
724                                    },
725                                );
726                            }
727                            __Field::m_uint8Data => {
728                                #[cfg(
729                                    any(feature = "strict", feature = "ignore_duplicates")
730                                )]
731                                if _serde::__private::Option::is_some(&m_uint8Data) {
732                                    #[cfg(feature = "ignore_duplicates")]
733                                    {
734                                        __A::skip_value(&mut __map)?;
735                                        continue;
736                                    }
737                                    #[cfg(feature = "strict")]
738                                    return _serde::__private::Err(
739                                        <__A::Error as _serde::de::Error>::duplicate_field(
740                                            "uint8Data",
741                                        ),
742                                    );
743                                }
744                                m_uint8Data = _serde::__private::Some(
745                                    match __A::next_value::<Vec<u8>>(&mut __map) {
746                                        _serde::__private::Ok(__val) => __val,
747                                        _serde::__private::Err(__err) => {
748                                            return _serde::__private::Err(__err);
749                                        }
750                                    },
751                                );
752                            }
753                            __Field::m_numVerts => {
754                                #[cfg(
755                                    any(feature = "strict", feature = "ignore_duplicates")
756                                )]
757                                if _serde::__private::Option::is_some(&m_numVerts) {
758                                    #[cfg(feature = "ignore_duplicates")]
759                                    {
760                                        __A::skip_value(&mut __map)?;
761                                        continue;
762                                    }
763                                    #[cfg(feature = "strict")]
764                                    return _serde::__private::Err(
765                                        <__A::Error as _serde::de::Error>::duplicate_field(
766                                            "numVerts",
767                                        ),
768                                    );
769                                }
770                                m_numVerts = _serde::__private::Some(
771                                    match __A::next_value::<u32>(&mut __map) {
772                                        _serde::__private::Ok(__val) => __val,
773                                        _serde::__private::Err(__err) => {
774                                            return _serde::__private::Err(__err);
775                                        }
776                                    },
777                                );
778                            }
779                            __Field::m_vectorStride => {
780                                #[cfg(
781                                    any(feature = "strict", feature = "ignore_duplicates")
782                                )]
783                                if _serde::__private::Option::is_some(&m_vectorStride) {
784                                    #[cfg(feature = "ignore_duplicates")]
785                                    {
786                                        __A::skip_value(&mut __map)?;
787                                        continue;
788                                    }
789                                    #[cfg(feature = "strict")]
790                                    return _serde::__private::Err(
791                                        <__A::Error as _serde::de::Error>::duplicate_field(
792                                            "vectorStride",
793                                        ),
794                                    );
795                                }
796                                m_vectorStride = _serde::__private::Some(
797                                    match __A::next_value::<u32>(&mut __map) {
798                                        _serde::__private::Ok(__val) => __val,
799                                        _serde::__private::Err(__err) => {
800                                            return _serde::__private::Err(__err);
801                                        }
802                                    },
803                                );
804                            }
805                            __Field::m_floatStride => {
806                                #[cfg(
807                                    any(feature = "strict", feature = "ignore_duplicates")
808                                )]
809                                if _serde::__private::Option::is_some(&m_floatStride) {
810                                    #[cfg(feature = "ignore_duplicates")]
811                                    {
812                                        __A::skip_value(&mut __map)?;
813                                        continue;
814                                    }
815                                    #[cfg(feature = "strict")]
816                                    return _serde::__private::Err(
817                                        <__A::Error as _serde::de::Error>::duplicate_field(
818                                            "floatStride",
819                                        ),
820                                    );
821                                }
822                                m_floatStride = _serde::__private::Some(
823                                    match __A::next_value::<u32>(&mut __map) {
824                                        _serde::__private::Ok(__val) => __val,
825                                        _serde::__private::Err(__err) => {
826                                            return _serde::__private::Err(__err);
827                                        }
828                                    },
829                                );
830                            }
831                            __Field::m_uint32Stride => {
832                                #[cfg(
833                                    any(feature = "strict", feature = "ignore_duplicates")
834                                )]
835                                if _serde::__private::Option::is_some(&m_uint32Stride) {
836                                    #[cfg(feature = "ignore_duplicates")]
837                                    {
838                                        __A::skip_value(&mut __map)?;
839                                        continue;
840                                    }
841                                    #[cfg(feature = "strict")]
842                                    return _serde::__private::Err(
843                                        <__A::Error as _serde::de::Error>::duplicate_field(
844                                            "uint32Stride",
845                                        ),
846                                    );
847                                }
848                                m_uint32Stride = _serde::__private::Some(
849                                    match __A::next_value::<u32>(&mut __map) {
850                                        _serde::__private::Ok(__val) => __val,
851                                        _serde::__private::Err(__err) => {
852                                            return _serde::__private::Err(__err);
853                                        }
854                                    },
855                                );
856                            }
857                            __Field::m_uint16Stride => {
858                                #[cfg(
859                                    any(feature = "strict", feature = "ignore_duplicates")
860                                )]
861                                if _serde::__private::Option::is_some(&m_uint16Stride) {
862                                    #[cfg(feature = "ignore_duplicates")]
863                                    {
864                                        __A::skip_value(&mut __map)?;
865                                        continue;
866                                    }
867                                    #[cfg(feature = "strict")]
868                                    return _serde::__private::Err(
869                                        <__A::Error as _serde::de::Error>::duplicate_field(
870                                            "uint16Stride",
871                                        ),
872                                    );
873                                }
874                                m_uint16Stride = _serde::__private::Some(
875                                    match __A::next_value::<u32>(&mut __map) {
876                                        _serde::__private::Ok(__val) => __val,
877                                        _serde::__private::Err(__err) => {
878                                            return _serde::__private::Err(__err);
879                                        }
880                                    },
881                                );
882                            }
883                            __Field::m_uint8Stride => {
884                                #[cfg(
885                                    any(feature = "strict", feature = "ignore_duplicates")
886                                )]
887                                if _serde::__private::Option::is_some(&m_uint8Stride) {
888                                    #[cfg(feature = "ignore_duplicates")]
889                                    {
890                                        __A::skip_value(&mut __map)?;
891                                        continue;
892                                    }
893                                    #[cfg(feature = "strict")]
894                                    return _serde::__private::Err(
895                                        <__A::Error as _serde::de::Error>::duplicate_field(
896                                            "uint8Stride",
897                                        ),
898                                    );
899                                }
900                                m_uint8Stride = _serde::__private::Some(
901                                    match __A::next_value::<u32>(&mut __map) {
902                                        _serde::__private::Ok(__val) => __val,
903                                        _serde::__private::Err(__err) => {
904                                            return _serde::__private::Err(__err);
905                                        }
906                                    },
907                                );
908                            }
909                            _ => __A::skip_value(&mut __map)?,
910                        }
911                    }
912                    let m_vectorData = match m_vectorData {
913                        _serde::__private::Some(__field) => __field,
914                        _serde::__private::None => {
915                            #[cfg(feature = "strict")]
916                            return _serde::__private::Err(
917                                <__A::Error as _serde::de::Error>::missing_field(
918                                    "vectorData",
919                                ),
920                            );
921                            #[cfg(not(feature = "strict"))] Default::default()
922                        }
923                    };
924                    let m_floatData = match m_floatData {
925                        _serde::__private::Some(__field) => __field,
926                        _serde::__private::None => {
927                            #[cfg(feature = "strict")]
928                            return _serde::__private::Err(
929                                <__A::Error as _serde::de::Error>::missing_field(
930                                    "floatData",
931                                ),
932                            );
933                            #[cfg(not(feature = "strict"))] Default::default()
934                        }
935                    };
936                    let m_uint32Data = match m_uint32Data {
937                        _serde::__private::Some(__field) => __field,
938                        _serde::__private::None => {
939                            #[cfg(feature = "strict")]
940                            return _serde::__private::Err(
941                                <__A::Error as _serde::de::Error>::missing_field(
942                                    "uint32Data",
943                                ),
944                            );
945                            #[cfg(not(feature = "strict"))] Default::default()
946                        }
947                    };
948                    let m_uint16Data = match m_uint16Data {
949                        _serde::__private::Some(__field) => __field,
950                        _serde::__private::None => {
951                            #[cfg(feature = "strict")]
952                            return _serde::__private::Err(
953                                <__A::Error as _serde::de::Error>::missing_field(
954                                    "uint16Data",
955                                ),
956                            );
957                            #[cfg(not(feature = "strict"))] Default::default()
958                        }
959                    };
960                    let m_uint8Data = match m_uint8Data {
961                        _serde::__private::Some(__field) => __field,
962                        _serde::__private::None => {
963                            #[cfg(feature = "strict")]
964                            return _serde::__private::Err(
965                                <__A::Error as _serde::de::Error>::missing_field(
966                                    "uint8Data",
967                                ),
968                            );
969                            #[cfg(not(feature = "strict"))] Default::default()
970                        }
971                    };
972                    let m_numVerts = match m_numVerts {
973                        _serde::__private::Some(__field) => __field,
974                        _serde::__private::None => {
975                            #[cfg(feature = "strict")]
976                            return _serde::__private::Err(
977                                <__A::Error as _serde::de::Error>::missing_field("numVerts"),
978                            );
979                            #[cfg(not(feature = "strict"))] Default::default()
980                        }
981                    };
982                    let m_vectorStride = match m_vectorStride {
983                        _serde::__private::Some(__field) => __field,
984                        _serde::__private::None => {
985                            #[cfg(feature = "strict")]
986                            return _serde::__private::Err(
987                                <__A::Error as _serde::de::Error>::missing_field(
988                                    "vectorStride",
989                                ),
990                            );
991                            #[cfg(not(feature = "strict"))] Default::default()
992                        }
993                    };
994                    let m_floatStride = match m_floatStride {
995                        _serde::__private::Some(__field) => __field,
996                        _serde::__private::None => {
997                            #[cfg(feature = "strict")]
998                            return _serde::__private::Err(
999                                <__A::Error as _serde::de::Error>::missing_field(
1000                                    "floatStride",
1001                                ),
1002                            );
1003                            #[cfg(not(feature = "strict"))] Default::default()
1004                        }
1005                    };
1006                    let m_uint32Stride = match m_uint32Stride {
1007                        _serde::__private::Some(__field) => __field,
1008                        _serde::__private::None => {
1009                            #[cfg(feature = "strict")]
1010                            return _serde::__private::Err(
1011                                <__A::Error as _serde::de::Error>::missing_field(
1012                                    "uint32Stride",
1013                                ),
1014                            );
1015                            #[cfg(not(feature = "strict"))] Default::default()
1016                        }
1017                    };
1018                    let m_uint16Stride = match m_uint16Stride {
1019                        _serde::__private::Some(__field) => __field,
1020                        _serde::__private::None => {
1021                            #[cfg(feature = "strict")]
1022                            return _serde::__private::Err(
1023                                <__A::Error as _serde::de::Error>::missing_field(
1024                                    "uint16Stride",
1025                                ),
1026                            );
1027                            #[cfg(not(feature = "strict"))] Default::default()
1028                        }
1029                    };
1030                    let m_uint8Stride = match m_uint8Stride {
1031                        _serde::__private::Some(__field) => __field,
1032                        _serde::__private::None => {
1033                            #[cfg(feature = "strict")]
1034                            return _serde::__private::Err(
1035                                <__A::Error as _serde::de::Error>::missing_field(
1036                                    "uint8Stride",
1037                                ),
1038                            );
1039                            #[cfg(not(feature = "strict"))] Default::default()
1040                        }
1041                    };
1042                    let __ptr = __A::class_ptr(&mut __map);
1043                    _serde::__private::Ok(hkxVertexBufferVertexData {
1044                        __ptr,
1045                        m_vectorData,
1046                        m_floatData,
1047                        m_uint32Data,
1048                        m_uint16Data,
1049                        m_uint8Data,
1050                        m_numVerts,
1051                        m_vectorStride,
1052                        m_floatStride,
1053                        m_uint32Stride,
1054                        m_uint16Stride,
1055                        m_uint8Stride,
1056                    })
1057                }
1058            }
1059            const FIELDS: &[&str] = &[
1060                "vectorData",
1061                "floatData",
1062                "uint32Data",
1063                "uint16Data",
1064                "uint8Data",
1065                "numVerts",
1066                "vectorStride",
1067                "floatStride",
1068                "uint32Stride",
1069                "uint16Stride",
1070                "uint8Stride",
1071            ];
1072            _serde::Deserializer::deserialize_struct(
1073                deserializer,
1074                "hkxVertexBufferVertexData",
1075                FIELDS,
1076                __hkxVertexBufferVertexDataVisitor {
1077                    marker: _serde::__private::PhantomData::<hkxVertexBufferVertexData>,
1078                    lifetime: _serde::__private::PhantomData,
1079                },
1080            )
1081        }
1082    }
1083};