havok_classes/generated/
hkMultipleVertexBufferLockedElement_.rs

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