havok_classes/generated/
hkMemoryMeshVertexBuffer_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkMemoryMeshVertexBuffer`
5/// - version: `1`
6/// - signature: `0xa2e50753`
7/// - size: `424`(x86)/`440`(x86_64)
8/// -  vtable: `true`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkMemoryMeshVertexBuffer {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkMeshVertexBuffer,
30    /// # C++ Info
31    /// - name: `format`(ctype: `struct hkVertexFormat`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `260`(x86)/`260`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "format"))]
35    #[cfg_attr(feature = "serde", serde(rename = "format"))]
36    pub m_format: hkVertexFormat,
37    /// # C++ Info
38    /// - name: `elementOffsets`(ctype: `hkInt32[32]`)
39    /// - offset: `268`(x86)/`276`(x86_64)
40    /// - type_size: `128`(x86)/`128`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "elementOffsets"))]
42    #[cfg_attr(feature = "serde", serde(rename = "elementOffsets"))]
43    pub m_elementOffsets: [i32; 32usize],
44    /// # C++ Info
45    /// - name: `memory`(ctype: `hkArray<hkUint8>`)
46    /// - offset: `396`(x86)/`408`(x86_64)
47    /// - type_size: ` 12`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "memory"))]
49    #[cfg_attr(feature = "serde", serde(rename = "memory"))]
50    pub m_memory: Vec<u8>,
51    /// # C++ Info
52    /// - name: `vertexStride`(ctype: `hkInt32`)
53    /// - offset: `408`(x86)/`424`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "vertexStride"))]
56    #[cfg_attr(feature = "serde", serde(rename = "vertexStride"))]
57    pub m_vertexStride: i32,
58    /// # C++ Info
59    /// - name: `locked`(ctype: `hkBool`)
60    /// - offset: `412`(x86)/`428`(x86_64)
61    /// - type_size: `  1`(x86)/`  1`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "locked"))]
63    #[cfg_attr(feature = "serde", serde(rename = "locked"))]
64    pub m_locked: bool,
65    /// # C++ Info
66    /// - name: `numVertices`(ctype: `hkInt32`)
67    /// - offset: `416`(x86)/`432`(x86_64)
68    /// - type_size: `  4`(x86)/`  4`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "numVertices"))]
70    #[cfg_attr(feature = "serde", serde(rename = "numVertices"))]
71    pub m_numVertices: i32,
72    /// # C++ Info
73    /// - name: `isBigEndian`(ctype: `hkBool`)
74    /// - offset: `420`(x86)/`436`(x86_64)
75    /// - type_size: `  1`(x86)/`  1`(x86_64)
76    #[cfg_attr(feature = "json_schema", schemars(rename = "isBigEndian"))]
77    #[cfg_attr(feature = "serde", serde(rename = "isBigEndian"))]
78    pub m_isBigEndian: bool,
79    /// # C++ Info
80    /// - name: `isSharable`(ctype: `hkBool`)
81    /// - offset: `421`(x86)/`437`(x86_64)
82    /// - type_size: `  1`(x86)/`  1`(x86_64)
83    #[cfg_attr(feature = "json_schema", schemars(rename = "isSharable"))]
84    #[cfg_attr(feature = "serde", serde(rename = "isSharable"))]
85    pub m_isSharable: bool,
86}
87const _: () = {
88    use havok_serde as _serde;
89    impl _serde::HavokClass for hkMemoryMeshVertexBuffer {
90        #[inline]
91        fn name(&self) -> &'static str {
92            "hkMemoryMeshVertexBuffer"
93        }
94        #[inline]
95        fn signature(&self) -> _serde::__private::Signature {
96            _serde::__private::Signature::new(0xa2e50753)
97        }
98        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
99        fn deps_indexes(&self) -> Vec<usize> {
100            let mut v = Vec::new();
101            v.extend(self.m_format.deps_indexes());
102            v
103        }
104    }
105    impl _serde::Serialize for hkMemoryMeshVertexBuffer {
106        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
107        where
108            S: _serde::ser::Serializer,
109        {
110            let class_meta = self
111                .__ptr
112                .map(|name| (name, _serde::__private::Signature::new(0xa2e50753)));
113            let mut serializer = __serializer
114                .serialize_struct(
115                    "hkMemoryMeshVertexBuffer",
116                    class_meta,
117                    (424u64, 440u64),
118                )?;
119            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
120            serializer
121                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
122            serializer
123                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
124            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
125            serializer.serialize_field("format", &self.m_format)?;
126            serializer
127                .serialize_fixed_array_field(
128                    "elementOffsets",
129                    self.m_elementOffsets.as_slice(),
130                    TypeSize::NonPtr,
131                )?;
132            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
133            serializer
134                .serialize_array_field("memory", &self.m_memory, TypeSize::NonPtr)?;
135            serializer.serialize_field("vertexStride", &self.m_vertexStride)?;
136            serializer.serialize_field("locked", &self.m_locked)?;
137            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
138            serializer.serialize_field("numVertices", &self.m_numVertices)?;
139            serializer.serialize_field("isBigEndian", &self.m_isBigEndian)?;
140            serializer.serialize_field("isSharable", &self.m_isSharable)?;
141            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
142            serializer.end()
143        }
144    }
145};
146#[doc(hidden)]
147#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
148const _: () = {
149    use havok_serde as _serde;
150    #[automatically_derived]
151    impl<'de> _serde::Deserialize<'de> for hkMemoryMeshVertexBuffer {
152        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
153        where
154            __D: _serde::Deserializer<'de>,
155        {
156            #[allow(non_camel_case_types)]
157            enum __Field {
158                m_format,
159                m_elementOffsets,
160                m_memory,
161                m_vertexStride,
162                m_locked,
163                m_numVertices,
164                m_isBigEndian,
165                m_isSharable,
166                __ignore,
167            }
168            struct __FieldVisitor;
169            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
170                type Value = __Field;
171                fn expecting(
172                    &self,
173                    __formatter: &mut core::fmt::Formatter,
174                ) -> core::fmt::Result {
175                    core::fmt::Formatter::write_str(__formatter, "field identifier")
176                }
177                /// Intended for use in XML.
178                #[allow(clippy::match_single_binding)]
179                #[allow(clippy::reversed_empty_ranges)]
180                #[allow(clippy::single_match)]
181                fn visit_key<__E>(
182                    self,
183                    __value: &str,
184                ) -> core::result::Result<Self::Value, __E>
185                where
186                    __E: _serde::de::Error,
187                {
188                    match __value {
189                        "format" => Ok(__Field::m_format),
190                        "elementOffsets" => Ok(__Field::m_elementOffsets),
191                        "memory" => Ok(__Field::m_memory),
192                        "vertexStride" => Ok(__Field::m_vertexStride),
193                        "locked" => Ok(__Field::m_locked),
194                        "numVertices" => Ok(__Field::m_numVertices),
195                        "isBigEndian" => Ok(__Field::m_isBigEndian),
196                        "isSharable" => Ok(__Field::m_isSharable),
197                        _ => Ok(__Field::__ignore),
198                    }
199                }
200            }
201            impl<'de> _serde::Deserialize<'de> for __Field {
202                #[inline]
203                fn deserialize<__D>(
204                    __deserializer: __D,
205                ) -> core::result::Result<Self, __D::Error>
206                where
207                    __D: _serde::Deserializer<'de>,
208                {
209                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
210                }
211            }
212            struct __hkMemoryMeshVertexBufferVisitor<'de> {
213                marker: _serde::__private::PhantomData<hkMemoryMeshVertexBuffer>,
214                lifetime: _serde::__private::PhantomData<&'de ()>,
215            }
216            #[allow(clippy::match_single_binding)]
217            #[allow(clippy::reversed_empty_ranges)]
218            #[allow(clippy::single_match)]
219            impl<'de> _serde::de::Visitor<'de>
220            for __hkMemoryMeshVertexBufferVisitor<'de> {
221                type Value = hkMemoryMeshVertexBuffer;
222                fn expecting(
223                    &self,
224                    __formatter: &mut core::fmt::Formatter,
225                ) -> core::fmt::Result {
226                    core::fmt::Formatter::write_str(
227                        __formatter,
228                        "struct hkMemoryMeshVertexBuffer",
229                    )
230                }
231                fn visit_struct_for_bytes<__A>(
232                    self,
233                    mut __map: __A,
234                ) -> _serde::__private::Result<Self::Value, __A::Error>
235                where
236                    __A: _serde::de::MapAccess<'de>,
237                {
238                    let __ptr = __A::class_ptr(&mut __map);
239                    let parent = __A::parent_value(&mut __map)?;
240                    let mut m_format: _serde::__private::Option<hkVertexFormat> = _serde::__private::None;
241                    let mut m_elementOffsets: _serde::__private::Option<
242                        [i32; 32usize],
243                    > = _serde::__private::None;
244                    let mut m_memory: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
245                    let mut m_vertexStride: _serde::__private::Option<i32> = _serde::__private::None;
246                    let mut m_locked: _serde::__private::Option<bool> = _serde::__private::None;
247                    let mut m_numVertices: _serde::__private::Option<i32> = _serde::__private::None;
248                    let mut m_isBigEndian: _serde::__private::Option<bool> = _serde::__private::None;
249                    let mut m_isSharable: _serde::__private::Option<bool> = _serde::__private::None;
250                    for i in 0..8usize {
251                        match i {
252                            0usize => {
253                                if _serde::__private::Option::is_some(&m_format) {
254                                    return _serde::__private::Err(
255                                        <__A::Error as _serde::de::Error>::duplicate_field("format"),
256                                    );
257                                }
258                                m_format = _serde::__private::Some(
259                                    match __A::next_value::<hkVertexFormat>(&mut __map) {
260                                        _serde::__private::Ok(__val) => __val,
261                                        _serde::__private::Err(__err) => {
262                                            return _serde::__private::Err(__err);
263                                        }
264                                    },
265                                );
266                            }
267                            1usize => {
268                                if _serde::__private::Option::is_some(&m_elementOffsets) {
269                                    return _serde::__private::Err(
270                                        <__A::Error as _serde::de::Error>::duplicate_field(
271                                            "elementOffsets",
272                                        ),
273                                    );
274                                }
275                                m_elementOffsets = _serde::__private::Some(
276                                    match __A::next_value::<[i32; 32usize]>(&mut __map) {
277                                        _serde::__private::Ok(__val) => __val,
278                                        _serde::__private::Err(__err) => {
279                                            return _serde::__private::Err(__err);
280                                        }
281                                    },
282                                );
283                            }
284                            2usize => {
285                                if _serde::__private::Option::is_some(&m_memory) {
286                                    return _serde::__private::Err(
287                                        <__A::Error as _serde::de::Error>::duplicate_field("memory"),
288                                    );
289                                }
290                                __A::pad(&mut __map, 0usize, 4usize)?;
291                                m_memory = _serde::__private::Some(
292                                    match __A::next_value::<Vec<u8>>(&mut __map) {
293                                        _serde::__private::Ok(__val) => __val,
294                                        _serde::__private::Err(__err) => {
295                                            return _serde::__private::Err(__err);
296                                        }
297                                    },
298                                );
299                            }
300                            3usize => {
301                                if _serde::__private::Option::is_some(&m_vertexStride) {
302                                    return _serde::__private::Err(
303                                        <__A::Error as _serde::de::Error>::duplicate_field(
304                                            "vertexStride",
305                                        ),
306                                    );
307                                }
308                                m_vertexStride = _serde::__private::Some(
309                                    match __A::next_value::<i32>(&mut __map) {
310                                        _serde::__private::Ok(__val) => __val,
311                                        _serde::__private::Err(__err) => {
312                                            return _serde::__private::Err(__err);
313                                        }
314                                    },
315                                );
316                            }
317                            4usize => {
318                                if _serde::__private::Option::is_some(&m_locked) {
319                                    return _serde::__private::Err(
320                                        <__A::Error as _serde::de::Error>::duplicate_field("locked"),
321                                    );
322                                }
323                                m_locked = _serde::__private::Some(
324                                    match __A::next_value::<bool>(&mut __map) {
325                                        _serde::__private::Ok(__val) => __val,
326                                        _serde::__private::Err(__err) => {
327                                            return _serde::__private::Err(__err);
328                                        }
329                                    },
330                                );
331                            }
332                            5usize => {
333                                if _serde::__private::Option::is_some(&m_numVertices) {
334                                    return _serde::__private::Err(
335                                        <__A::Error as _serde::de::Error>::duplicate_field(
336                                            "numVertices",
337                                        ),
338                                    );
339                                }
340                                __A::pad(&mut __map, 3usize, 3usize)?;
341                                m_numVertices = _serde::__private::Some(
342                                    match __A::next_value::<i32>(&mut __map) {
343                                        _serde::__private::Ok(__val) => __val,
344                                        _serde::__private::Err(__err) => {
345                                            return _serde::__private::Err(__err);
346                                        }
347                                    },
348                                );
349                            }
350                            6usize => {
351                                if _serde::__private::Option::is_some(&m_isBigEndian) {
352                                    return _serde::__private::Err(
353                                        <__A::Error as _serde::de::Error>::duplicate_field(
354                                            "isBigEndian",
355                                        ),
356                                    );
357                                }
358                                m_isBigEndian = _serde::__private::Some(
359                                    match __A::next_value::<bool>(&mut __map) {
360                                        _serde::__private::Ok(__val) => __val,
361                                        _serde::__private::Err(__err) => {
362                                            return _serde::__private::Err(__err);
363                                        }
364                                    },
365                                );
366                            }
367                            7usize => {
368                                if _serde::__private::Option::is_some(&m_isSharable) {
369                                    return _serde::__private::Err(
370                                        <__A::Error as _serde::de::Error>::duplicate_field(
371                                            "isSharable",
372                                        ),
373                                    );
374                                }
375                                m_isSharable = _serde::__private::Some(
376                                    match __A::next_value::<bool>(&mut __map) {
377                                        _serde::__private::Ok(__val) => __val,
378                                        _serde::__private::Err(__err) => {
379                                            return _serde::__private::Err(__err);
380                                        }
381                                    },
382                                );
383                            }
384                            _ => {}
385                        }
386                    }
387                    __A::pad(&mut __map, 2usize, 2usize)?;
388                    let m_format = match m_format {
389                        _serde::__private::Some(__field) => __field,
390                        _serde::__private::None => {
391                            return _serde::__private::Err(
392                                <__A::Error as _serde::de::Error>::missing_field("format"),
393                            );
394                        }
395                    };
396                    let m_elementOffsets = match m_elementOffsets {
397                        _serde::__private::Some(__field) => __field,
398                        _serde::__private::None => {
399                            return _serde::__private::Err(
400                                <__A::Error as _serde::de::Error>::missing_field(
401                                    "elementOffsets",
402                                ),
403                            );
404                        }
405                    };
406                    let m_memory = match m_memory {
407                        _serde::__private::Some(__field) => __field,
408                        _serde::__private::None => {
409                            return _serde::__private::Err(
410                                <__A::Error as _serde::de::Error>::missing_field("memory"),
411                            );
412                        }
413                    };
414                    let m_vertexStride = match m_vertexStride {
415                        _serde::__private::Some(__field) => __field,
416                        _serde::__private::None => {
417                            return _serde::__private::Err(
418                                <__A::Error as _serde::de::Error>::missing_field(
419                                    "vertexStride",
420                                ),
421                            );
422                        }
423                    };
424                    let m_locked = match m_locked {
425                        _serde::__private::Some(__field) => __field,
426                        _serde::__private::None => {
427                            return _serde::__private::Err(
428                                <__A::Error as _serde::de::Error>::missing_field("locked"),
429                            );
430                        }
431                    };
432                    let m_numVertices = match m_numVertices {
433                        _serde::__private::Some(__field) => __field,
434                        _serde::__private::None => {
435                            return _serde::__private::Err(
436                                <__A::Error as _serde::de::Error>::missing_field(
437                                    "numVertices",
438                                ),
439                            );
440                        }
441                    };
442                    let m_isBigEndian = match m_isBigEndian {
443                        _serde::__private::Some(__field) => __field,
444                        _serde::__private::None => {
445                            return _serde::__private::Err(
446                                <__A::Error as _serde::de::Error>::missing_field(
447                                    "isBigEndian",
448                                ),
449                            );
450                        }
451                    };
452                    let m_isSharable = match m_isSharable {
453                        _serde::__private::Some(__field) => __field,
454                        _serde::__private::None => {
455                            return _serde::__private::Err(
456                                <__A::Error as _serde::de::Error>::missing_field(
457                                    "isSharable",
458                                ),
459                            );
460                        }
461                    };
462                    _serde::__private::Ok(hkMemoryMeshVertexBuffer {
463                        __ptr,
464                        parent,
465                        m_format,
466                        m_elementOffsets,
467                        m_memory,
468                        m_vertexStride,
469                        m_locked,
470                        m_numVertices,
471                        m_isBigEndian,
472                        m_isSharable,
473                    })
474                }
475                #[allow(clippy::manual_unwrap_or_default)]
476                fn visit_struct<__A>(
477                    self,
478                    mut __map: __A,
479                ) -> _serde::__private::Result<Self::Value, __A::Error>
480                where
481                    __A: _serde::de::MapAccess<'de>,
482                {
483                    let mut m_format: _serde::__private::Option<hkVertexFormat> = _serde::__private::None;
484                    let mut m_elementOffsets: _serde::__private::Option<
485                        [i32; 32usize],
486                    > = _serde::__private::None;
487                    let mut m_memory: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
488                    let mut m_vertexStride: _serde::__private::Option<i32> = _serde::__private::None;
489                    let mut m_locked: _serde::__private::Option<bool> = _serde::__private::None;
490                    let mut m_numVertices: _serde::__private::Option<i32> = _serde::__private::None;
491                    let mut m_isBigEndian: _serde::__private::Option<bool> = _serde::__private::None;
492                    let mut m_isSharable: _serde::__private::Option<bool> = _serde::__private::None;
493                    while let _serde::__private::Some(__key) = {
494                        __A::next_key::<__Field>(&mut __map)?
495                    } {
496                        match __key {
497                            __Field::m_format => {
498                                #[cfg(
499                                    any(feature = "strict", feature = "ignore_duplicates")
500                                )]
501                                if _serde::__private::Option::is_some(&m_format) {
502                                    #[cfg(feature = "ignore_duplicates")]
503                                    {
504                                        __A::skip_value(&mut __map)?;
505                                        continue;
506                                    }
507                                    #[cfg(feature = "strict")]
508                                    return _serde::__private::Err(
509                                        <__A::Error as _serde::de::Error>::duplicate_field("format"),
510                                    );
511                                }
512                                m_format = _serde::__private::Some(
513                                    match __A::next_value::<hkVertexFormat>(&mut __map) {
514                                        _serde::__private::Ok(__val) => __val,
515                                        _serde::__private::Err(__err) => {
516                                            return _serde::__private::Err(__err);
517                                        }
518                                    },
519                                );
520                            }
521                            __Field::m_elementOffsets => {
522                                #[cfg(
523                                    any(feature = "strict", feature = "ignore_duplicates")
524                                )]
525                                if _serde::__private::Option::is_some(&m_elementOffsets) {
526                                    #[cfg(feature = "ignore_duplicates")]
527                                    {
528                                        __A::skip_value(&mut __map)?;
529                                        continue;
530                                    }
531                                    #[cfg(feature = "strict")]
532                                    return _serde::__private::Err(
533                                        <__A::Error as _serde::de::Error>::duplicate_field(
534                                            "elementOffsets",
535                                        ),
536                                    );
537                                }
538                                m_elementOffsets = _serde::__private::Some(
539                                    match __A::next_value::<[i32; 32usize]>(&mut __map) {
540                                        _serde::__private::Ok(__val) => __val,
541                                        _serde::__private::Err(__err) => {
542                                            return _serde::__private::Err(__err);
543                                        }
544                                    },
545                                );
546                            }
547                            __Field::m_memory => {
548                                #[cfg(
549                                    any(feature = "strict", feature = "ignore_duplicates")
550                                )]
551                                if _serde::__private::Option::is_some(&m_memory) {
552                                    #[cfg(feature = "ignore_duplicates")]
553                                    {
554                                        __A::skip_value(&mut __map)?;
555                                        continue;
556                                    }
557                                    #[cfg(feature = "strict")]
558                                    return _serde::__private::Err(
559                                        <__A::Error as _serde::de::Error>::duplicate_field("memory"),
560                                    );
561                                }
562                                m_memory = _serde::__private::Some(
563                                    match __A::next_value::<Vec<u8>>(&mut __map) {
564                                        _serde::__private::Ok(__val) => __val,
565                                        _serde::__private::Err(__err) => {
566                                            return _serde::__private::Err(__err);
567                                        }
568                                    },
569                                );
570                            }
571                            __Field::m_vertexStride => {
572                                #[cfg(
573                                    any(feature = "strict", feature = "ignore_duplicates")
574                                )]
575                                if _serde::__private::Option::is_some(&m_vertexStride) {
576                                    #[cfg(feature = "ignore_duplicates")]
577                                    {
578                                        __A::skip_value(&mut __map)?;
579                                        continue;
580                                    }
581                                    #[cfg(feature = "strict")]
582                                    return _serde::__private::Err(
583                                        <__A::Error as _serde::de::Error>::duplicate_field(
584                                            "vertexStride",
585                                        ),
586                                    );
587                                }
588                                m_vertexStride = _serde::__private::Some(
589                                    match __A::next_value::<i32>(&mut __map) {
590                                        _serde::__private::Ok(__val) => __val,
591                                        _serde::__private::Err(__err) => {
592                                            return _serde::__private::Err(__err);
593                                        }
594                                    },
595                                );
596                            }
597                            __Field::m_locked => {
598                                #[cfg(
599                                    any(feature = "strict", feature = "ignore_duplicates")
600                                )]
601                                if _serde::__private::Option::is_some(&m_locked) {
602                                    #[cfg(feature = "ignore_duplicates")]
603                                    {
604                                        __A::skip_value(&mut __map)?;
605                                        continue;
606                                    }
607                                    #[cfg(feature = "strict")]
608                                    return _serde::__private::Err(
609                                        <__A::Error as _serde::de::Error>::duplicate_field("locked"),
610                                    );
611                                }
612                                m_locked = _serde::__private::Some(
613                                    match __A::next_value::<bool>(&mut __map) {
614                                        _serde::__private::Ok(__val) => __val,
615                                        _serde::__private::Err(__err) => {
616                                            return _serde::__private::Err(__err);
617                                        }
618                                    },
619                                );
620                            }
621                            __Field::m_numVertices => {
622                                #[cfg(
623                                    any(feature = "strict", feature = "ignore_duplicates")
624                                )]
625                                if _serde::__private::Option::is_some(&m_numVertices) {
626                                    #[cfg(feature = "ignore_duplicates")]
627                                    {
628                                        __A::skip_value(&mut __map)?;
629                                        continue;
630                                    }
631                                    #[cfg(feature = "strict")]
632                                    return _serde::__private::Err(
633                                        <__A::Error as _serde::de::Error>::duplicate_field(
634                                            "numVertices",
635                                        ),
636                                    );
637                                }
638                                m_numVertices = _serde::__private::Some(
639                                    match __A::next_value::<i32>(&mut __map) {
640                                        _serde::__private::Ok(__val) => __val,
641                                        _serde::__private::Err(__err) => {
642                                            return _serde::__private::Err(__err);
643                                        }
644                                    },
645                                );
646                            }
647                            __Field::m_isBigEndian => {
648                                #[cfg(
649                                    any(feature = "strict", feature = "ignore_duplicates")
650                                )]
651                                if _serde::__private::Option::is_some(&m_isBigEndian) {
652                                    #[cfg(feature = "ignore_duplicates")]
653                                    {
654                                        __A::skip_value(&mut __map)?;
655                                        continue;
656                                    }
657                                    #[cfg(feature = "strict")]
658                                    return _serde::__private::Err(
659                                        <__A::Error as _serde::de::Error>::duplicate_field(
660                                            "isBigEndian",
661                                        ),
662                                    );
663                                }
664                                m_isBigEndian = _serde::__private::Some(
665                                    match __A::next_value::<bool>(&mut __map) {
666                                        _serde::__private::Ok(__val) => __val,
667                                        _serde::__private::Err(__err) => {
668                                            return _serde::__private::Err(__err);
669                                        }
670                                    },
671                                );
672                            }
673                            __Field::m_isSharable => {
674                                #[cfg(
675                                    any(feature = "strict", feature = "ignore_duplicates")
676                                )]
677                                if _serde::__private::Option::is_some(&m_isSharable) {
678                                    #[cfg(feature = "ignore_duplicates")]
679                                    {
680                                        __A::skip_value(&mut __map)?;
681                                        continue;
682                                    }
683                                    #[cfg(feature = "strict")]
684                                    return _serde::__private::Err(
685                                        <__A::Error as _serde::de::Error>::duplicate_field(
686                                            "isSharable",
687                                        ),
688                                    );
689                                }
690                                m_isSharable = _serde::__private::Some(
691                                    match __A::next_value::<bool>(&mut __map) {
692                                        _serde::__private::Ok(__val) => __val,
693                                        _serde::__private::Err(__err) => {
694                                            return _serde::__private::Err(__err);
695                                        }
696                                    },
697                                );
698                            }
699                            _ => __A::skip_value(&mut __map)?,
700                        }
701                    }
702                    let m_format = match m_format {
703                        _serde::__private::Some(__field) => __field,
704                        _serde::__private::None => {
705                            #[cfg(feature = "strict")]
706                            return _serde::__private::Err(
707                                <__A::Error as _serde::de::Error>::missing_field("format"),
708                            );
709                            #[cfg(not(feature = "strict"))] Default::default()
710                        }
711                    };
712                    let m_elementOffsets = match m_elementOffsets {
713                        _serde::__private::Some(__field) => __field,
714                        _serde::__private::None => {
715                            #[cfg(feature = "strict")]
716                            return _serde::__private::Err(
717                                <__A::Error as _serde::de::Error>::missing_field(
718                                    "elementOffsets",
719                                ),
720                            );
721                            #[cfg(not(feature = "strict"))] Default::default()
722                        }
723                    };
724                    let m_memory = match m_memory {
725                        _serde::__private::Some(__field) => __field,
726                        _serde::__private::None => {
727                            #[cfg(feature = "strict")]
728                            return _serde::__private::Err(
729                                <__A::Error as _serde::de::Error>::missing_field("memory"),
730                            );
731                            #[cfg(not(feature = "strict"))] Default::default()
732                        }
733                    };
734                    let m_vertexStride = match m_vertexStride {
735                        _serde::__private::Some(__field) => __field,
736                        _serde::__private::None => {
737                            #[cfg(feature = "strict")]
738                            return _serde::__private::Err(
739                                <__A::Error as _serde::de::Error>::missing_field(
740                                    "vertexStride",
741                                ),
742                            );
743                            #[cfg(not(feature = "strict"))] Default::default()
744                        }
745                    };
746                    let m_locked = match m_locked {
747                        _serde::__private::Some(__field) => __field,
748                        _serde::__private::None => {
749                            #[cfg(feature = "strict")]
750                            return _serde::__private::Err(
751                                <__A::Error as _serde::de::Error>::missing_field("locked"),
752                            );
753                            #[cfg(not(feature = "strict"))] Default::default()
754                        }
755                    };
756                    let m_numVertices = match m_numVertices {
757                        _serde::__private::Some(__field) => __field,
758                        _serde::__private::None => {
759                            #[cfg(feature = "strict")]
760                            return _serde::__private::Err(
761                                <__A::Error as _serde::de::Error>::missing_field(
762                                    "numVertices",
763                                ),
764                            );
765                            #[cfg(not(feature = "strict"))] Default::default()
766                        }
767                    };
768                    let m_isBigEndian = match m_isBigEndian {
769                        _serde::__private::Some(__field) => __field,
770                        _serde::__private::None => {
771                            #[cfg(feature = "strict")]
772                            return _serde::__private::Err(
773                                <__A::Error as _serde::de::Error>::missing_field(
774                                    "isBigEndian",
775                                ),
776                            );
777                            #[cfg(not(feature = "strict"))] Default::default()
778                        }
779                    };
780                    let m_isSharable = match m_isSharable {
781                        _serde::__private::Some(__field) => __field,
782                        _serde::__private::None => {
783                            #[cfg(feature = "strict")]
784                            return _serde::__private::Err(
785                                <__A::Error as _serde::de::Error>::missing_field(
786                                    "isSharable",
787                                ),
788                            );
789                            #[cfg(not(feature = "strict"))] Default::default()
790                        }
791                    };
792                    let __ptr = None;
793                    let parent = hkBaseObject { __ptr };
794                    let parent = hkReferencedObject {
795                        __ptr,
796                        parent,
797                        ..Default::default()
798                    };
799                    let parent = hkMeshVertexBuffer {
800                        __ptr,
801                        parent,
802                    };
803                    let __ptr = __A::class_ptr(&mut __map);
804                    _serde::__private::Ok(hkMemoryMeshVertexBuffer {
805                        __ptr,
806                        parent,
807                        m_format,
808                        m_elementOffsets,
809                        m_memory,
810                        m_vertexStride,
811                        m_locked,
812                        m_numVertices,
813                        m_isBigEndian,
814                        m_isSharable,
815                    })
816                }
817            }
818            const FIELDS: &[&str] = &[
819                "format",
820                "elementOffsets",
821                "memory",
822                "vertexStride",
823                "locked",
824                "numVertices",
825                "isBigEndian",
826                "isSharable",
827            ];
828            _serde::Deserializer::deserialize_struct(
829                deserializer,
830                "hkMemoryMeshVertexBuffer",
831                FIELDS,
832                __hkMemoryMeshVertexBufferVisitor {
833                    marker: _serde::__private::PhantomData::<hkMemoryMeshVertexBuffer>,
834                    lifetime: _serde::__private::PhantomData,
835                },
836            )
837        }
838    }
839};