havok_classes/generated/
hkMultipleVertexBuffer_.rs

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