havok_classes/generated/
hkMeshSection_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkMeshSection`
5/// - version: `1`
6/// - signature: `0x1893c365`
7/// - size: ` 40`(x86)/` 56`(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 hkMeshSection {
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: `primitiveType`(ctype: `enum PrimitiveType`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  1`(x86)/`  1`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "primitiveType"))]
31    #[cfg_attr(feature = "serde", serde(rename = "primitiveType"))]
32    pub m_primitiveType: PrimitiveType,
33    /// # C++ Info
34    /// - name: `numPrimitives`(ctype: `hkInt32`)
35    /// - offset: `  4`(x86)/`  4`(x86_64)
36    /// - type_size: `  4`(x86)/`  4`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "numPrimitives"))]
38    #[cfg_attr(feature = "serde", serde(rename = "numPrimitives"))]
39    pub m_numPrimitives: i32,
40    /// # C++ Info
41    /// - name: `numIndices`(ctype: `hkInt32`)
42    /// - offset: `  8`(x86)/`  8`(x86_64)
43    /// - type_size: `  4`(x86)/`  4`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "numIndices"))]
45    #[cfg_attr(feature = "serde", serde(rename = "numIndices"))]
46    pub m_numIndices: i32,
47    /// # C++ Info
48    /// - name: `vertexStartIndex`(ctype: `hkInt32`)
49    /// - offset: ` 12`(x86)/` 12`(x86_64)
50    /// - type_size: `  4`(x86)/`  4`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "vertexStartIndex"))]
52    #[cfg_attr(feature = "serde", serde(rename = "vertexStartIndex"))]
53    pub m_vertexStartIndex: i32,
54    /// # C++ Info
55    /// - name: `transformIndex`(ctype: `hkInt32`)
56    /// - offset: ` 16`(x86)/` 16`(x86_64)
57    /// - type_size: `  4`(x86)/`  4`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "transformIndex"))]
59    #[cfg_attr(feature = "serde", serde(rename = "transformIndex"))]
60    pub m_transformIndex: i32,
61    /// # C++ Info
62    /// - name: `indexType`(ctype: `enum MeshSectionIndexType`)
63    /// - offset: ` 20`(x86)/` 20`(x86_64)
64    /// - type_size: `  1`(x86)/`  1`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "indexType"))]
66    #[cfg_attr(feature = "serde", serde(rename = "indexType"))]
67    pub m_indexType: MeshSectionIndexType,
68    /// # C++ Info
69    /// - name: `indices`(ctype: `void*`)
70    /// - offset: ` 24`(x86)/` 24`(x86_64)
71    /// - type_size: `  4`(x86)/`  8`(x86_64)
72    /// - flags: `SERIALIZE_IGNORED`
73    #[cfg_attr(feature = "json_schema", schemars(rename = "indices"))]
74    #[cfg_attr(feature = "serde", serde(rename = "indices"))]
75    pub m_indices: Pointer,
76    /// # C++ Info
77    /// - name: `vertexBuffer`(ctype: `struct hkMeshVertexBuffer*`)
78    /// - offset: ` 28`(x86)/` 32`(x86_64)
79    /// - type_size: `  4`(x86)/`  8`(x86_64)
80    #[cfg_attr(feature = "json_schema", schemars(rename = "vertexBuffer"))]
81    #[cfg_attr(feature = "serde", serde(rename = "vertexBuffer"))]
82    pub m_vertexBuffer: Pointer,
83    /// # C++ Info
84    /// - name: `material`(ctype: `struct hkMeshMaterial*`)
85    /// - offset: ` 32`(x86)/` 40`(x86_64)
86    /// - type_size: `  4`(x86)/`  8`(x86_64)
87    #[cfg_attr(feature = "json_schema", schemars(rename = "material"))]
88    #[cfg_attr(feature = "serde", serde(rename = "material"))]
89    pub m_material: Pointer,
90    /// # C++ Info
91    /// - name: `sectionIndex`(ctype: `hkInt32`)
92    /// - offset: ` 36`(x86)/` 48`(x86_64)
93    /// - type_size: `  4`(x86)/`  4`(x86_64)
94    #[cfg_attr(feature = "json_schema", schemars(rename = "sectionIndex"))]
95    #[cfg_attr(feature = "serde", serde(rename = "sectionIndex"))]
96    pub m_sectionIndex: i32,
97}
98const _: () = {
99    use havok_serde as _serde;
100    impl _serde::HavokClass for hkMeshSection {
101        #[inline]
102        fn name(&self) -> &'static str {
103            "hkMeshSection"
104        }
105        #[inline]
106        fn signature(&self) -> _serde::__private::Signature {
107            _serde::__private::Signature::new(0x1893c365)
108        }
109        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
110        fn deps_indexes(&self) -> Vec<usize> {
111            let mut v = Vec::new();
112            v.push(self.m_indices.get());
113            v.push(self.m_vertexBuffer.get());
114            v.push(self.m_material.get());
115            v
116        }
117    }
118    impl _serde::Serialize for hkMeshSection {
119        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
120        where
121            S: _serde::ser::Serializer,
122        {
123            let class_meta = self
124                .__ptr
125                .map(|name| (name, _serde::__private::Signature::new(0x1893c365)));
126            let mut serializer = __serializer
127                .serialize_struct("hkMeshSection", class_meta, (40u64, 56u64))?;
128            serializer.serialize_field("primitiveType", &self.m_primitiveType)?;
129            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
130            serializer.serialize_field("numPrimitives", &self.m_numPrimitives)?;
131            serializer.serialize_field("numIndices", &self.m_numIndices)?;
132            serializer.serialize_field("vertexStartIndex", &self.m_vertexStartIndex)?;
133            serializer.serialize_field("transformIndex", &self.m_transformIndex)?;
134            serializer.serialize_field("indexType", &self.m_indexType)?;
135            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
136            serializer.skip_field("indices", &self.m_indices)?;
137            serializer.serialize_field("vertexBuffer", &self.m_vertexBuffer)?;
138            serializer.serialize_field("material", &self.m_material)?;
139            serializer.serialize_field("sectionIndex", &self.m_sectionIndex)?;
140            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
141            serializer.end()
142        }
143    }
144};
145#[doc(hidden)]
146#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
147const _: () = {
148    use havok_serde as _serde;
149    #[automatically_derived]
150    impl<'de> _serde::Deserialize<'de> for hkMeshSection {
151        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
152        where
153            __D: _serde::Deserializer<'de>,
154        {
155            #[allow(non_camel_case_types)]
156            enum __Field {
157                m_primitiveType,
158                m_numPrimitives,
159                m_numIndices,
160                m_vertexStartIndex,
161                m_transformIndex,
162                m_indexType,
163                m_vertexBuffer,
164                m_material,
165                m_sectionIndex,
166                __ignore,
167            }
168            struct __FieldVisitor;
169            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
170                type Value = __Field;
171                fn expecting(
172                    &self,
173                    __formatter: &mut core::fmt::Formatter,
174                ) -> core::fmt::Result {
175                    core::fmt::Formatter::write_str(__formatter, "field identifier")
176                }
177                /// Intended for use in XML.
178                #[allow(clippy::match_single_binding)]
179                #[allow(clippy::reversed_empty_ranges)]
180                #[allow(clippy::single_match)]
181                fn visit_key<__E>(
182                    self,
183                    __value: &str,
184                ) -> core::result::Result<Self::Value, __E>
185                where
186                    __E: _serde::de::Error,
187                {
188                    match __value {
189                        "primitiveType" => Ok(__Field::m_primitiveType),
190                        "numPrimitives" => Ok(__Field::m_numPrimitives),
191                        "numIndices" => Ok(__Field::m_numIndices),
192                        "vertexStartIndex" => Ok(__Field::m_vertexStartIndex),
193                        "transformIndex" => Ok(__Field::m_transformIndex),
194                        "indexType" => Ok(__Field::m_indexType),
195                        "vertexBuffer" => Ok(__Field::m_vertexBuffer),
196                        "material" => Ok(__Field::m_material),
197                        "sectionIndex" => Ok(__Field::m_sectionIndex),
198                        _ => Ok(__Field::__ignore),
199                    }
200                }
201            }
202            impl<'de> _serde::Deserialize<'de> for __Field {
203                #[inline]
204                fn deserialize<__D>(
205                    __deserializer: __D,
206                ) -> core::result::Result<Self, __D::Error>
207                where
208                    __D: _serde::Deserializer<'de>,
209                {
210                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
211                }
212            }
213            struct __hkMeshSectionVisitor<'de> {
214                marker: _serde::__private::PhantomData<hkMeshSection>,
215                lifetime: _serde::__private::PhantomData<&'de ()>,
216            }
217            #[allow(clippy::match_single_binding)]
218            #[allow(clippy::reversed_empty_ranges)]
219            #[allow(clippy::single_match)]
220            impl<'de> _serde::de::Visitor<'de> for __hkMeshSectionVisitor<'de> {
221                type Value = hkMeshSection;
222                fn expecting(
223                    &self,
224                    __formatter: &mut core::fmt::Formatter,
225                ) -> core::fmt::Result {
226                    core::fmt::Formatter::write_str(__formatter, "struct hkMeshSection")
227                }
228                fn visit_struct_for_bytes<__A>(
229                    self,
230                    mut __map: __A,
231                ) -> _serde::__private::Result<Self::Value, __A::Error>
232                where
233                    __A: _serde::de::MapAccess<'de>,
234                {
235                    let __ptr = __A::class_ptr(&mut __map);
236                    let mut m_primitiveType: _serde::__private::Option<PrimitiveType> = _serde::__private::None;
237                    let mut m_numPrimitives: _serde::__private::Option<i32> = _serde::__private::None;
238                    let mut m_numIndices: _serde::__private::Option<i32> = _serde::__private::None;
239                    let mut m_vertexStartIndex: _serde::__private::Option<i32> = _serde::__private::None;
240                    let mut m_transformIndex: _serde::__private::Option<i32> = _serde::__private::None;
241                    let mut m_indexType: _serde::__private::Option<
242                        MeshSectionIndexType,
243                    > = _serde::__private::None;
244                    let mut m_indices: _serde::__private::Option<Pointer> = _serde::__private::None;
245                    let mut m_vertexBuffer: _serde::__private::Option<Pointer> = _serde::__private::None;
246                    let mut m_material: _serde::__private::Option<Pointer> = _serde::__private::None;
247                    let mut m_sectionIndex: _serde::__private::Option<i32> = _serde::__private::None;
248                    for i in 0..10usize {
249                        match i {
250                            0usize => {
251                                if _serde::__private::Option::is_some(&m_primitiveType) {
252                                    return _serde::__private::Err(
253                                        <__A::Error as _serde::de::Error>::duplicate_field(
254                                            "primitiveType",
255                                        ),
256                                    );
257                                }
258                                m_primitiveType = _serde::__private::Some(
259                                    match __A::next_value::<PrimitiveType>(&mut __map) {
260                                        _serde::__private::Ok(__val) => __val,
261                                        _serde::__private::Err(__err) => {
262                                            return _serde::__private::Err(__err);
263                                        }
264                                    },
265                                );
266                            }
267                            1usize => {
268                                if _serde::__private::Option::is_some(&m_numPrimitives) {
269                                    return _serde::__private::Err(
270                                        <__A::Error as _serde::de::Error>::duplicate_field(
271                                            "numPrimitives",
272                                        ),
273                                    );
274                                }
275                                __A::pad(&mut __map, 3usize, 3usize)?;
276                                m_numPrimitives = _serde::__private::Some(
277                                    match __A::next_value::<i32>(&mut __map) {
278                                        _serde::__private::Ok(__val) => __val,
279                                        _serde::__private::Err(__err) => {
280                                            return _serde::__private::Err(__err);
281                                        }
282                                    },
283                                );
284                            }
285                            2usize => {
286                                if _serde::__private::Option::is_some(&m_numIndices) {
287                                    return _serde::__private::Err(
288                                        <__A::Error as _serde::de::Error>::duplicate_field(
289                                            "numIndices",
290                                        ),
291                                    );
292                                }
293                                m_numIndices = _serde::__private::Some(
294                                    match __A::next_value::<i32>(&mut __map) {
295                                        _serde::__private::Ok(__val) => __val,
296                                        _serde::__private::Err(__err) => {
297                                            return _serde::__private::Err(__err);
298                                        }
299                                    },
300                                );
301                            }
302                            3usize => {
303                                if _serde::__private::Option::is_some(&m_vertexStartIndex) {
304                                    return _serde::__private::Err(
305                                        <__A::Error as _serde::de::Error>::duplicate_field(
306                                            "vertexStartIndex",
307                                        ),
308                                    );
309                                }
310                                m_vertexStartIndex = _serde::__private::Some(
311                                    match __A::next_value::<i32>(&mut __map) {
312                                        _serde::__private::Ok(__val) => __val,
313                                        _serde::__private::Err(__err) => {
314                                            return _serde::__private::Err(__err);
315                                        }
316                                    },
317                                );
318                            }
319                            4usize => {
320                                if _serde::__private::Option::is_some(&m_transformIndex) {
321                                    return _serde::__private::Err(
322                                        <__A::Error as _serde::de::Error>::duplicate_field(
323                                            "transformIndex",
324                                        ),
325                                    );
326                                }
327                                m_transformIndex = _serde::__private::Some(
328                                    match __A::next_value::<i32>(&mut __map) {
329                                        _serde::__private::Ok(__val) => __val,
330                                        _serde::__private::Err(__err) => {
331                                            return _serde::__private::Err(__err);
332                                        }
333                                    },
334                                );
335                            }
336                            5usize => {
337                                if _serde::__private::Option::is_some(&m_indexType) {
338                                    return _serde::__private::Err(
339                                        <__A::Error as _serde::de::Error>::duplicate_field(
340                                            "indexType",
341                                        ),
342                                    );
343                                }
344                                m_indexType = _serde::__private::Some(
345                                    match __A::next_value::<MeshSectionIndexType>(&mut __map) {
346                                        _serde::__private::Ok(__val) => __val,
347                                        _serde::__private::Err(__err) => {
348                                            return _serde::__private::Err(__err);
349                                        }
350                                    },
351                                );
352                            }
353                            6usize => {
354                                if _serde::__private::Option::is_some(&m_indices) {
355                                    return _serde::__private::Err(
356                                        <__A::Error as _serde::de::Error>::duplicate_field(
357                                            "indices",
358                                        ),
359                                    );
360                                }
361                                __A::pad(&mut __map, 3usize, 3usize)?;
362                                m_indices = _serde::__private::Some(
363                                    match __A::next_value::<Pointer>(&mut __map) {
364                                        _serde::__private::Ok(__val) => __val,
365                                        _serde::__private::Err(__err) => {
366                                            return _serde::__private::Err(__err);
367                                        }
368                                    },
369                                );
370                            }
371                            7usize => {
372                                if _serde::__private::Option::is_some(&m_vertexBuffer) {
373                                    return _serde::__private::Err(
374                                        <__A::Error as _serde::de::Error>::duplicate_field(
375                                            "vertexBuffer",
376                                        ),
377                                    );
378                                }
379                                m_vertexBuffer = _serde::__private::Some(
380                                    match __A::next_value::<Pointer>(&mut __map) {
381                                        _serde::__private::Ok(__val) => __val,
382                                        _serde::__private::Err(__err) => {
383                                            return _serde::__private::Err(__err);
384                                        }
385                                    },
386                                );
387                            }
388                            8usize => {
389                                if _serde::__private::Option::is_some(&m_material) {
390                                    return _serde::__private::Err(
391                                        <__A::Error as _serde::de::Error>::duplicate_field(
392                                            "material",
393                                        ),
394                                    );
395                                }
396                                m_material = _serde::__private::Some(
397                                    match __A::next_value::<Pointer>(&mut __map) {
398                                        _serde::__private::Ok(__val) => __val,
399                                        _serde::__private::Err(__err) => {
400                                            return _serde::__private::Err(__err);
401                                        }
402                                    },
403                                );
404                            }
405                            9usize => {
406                                if _serde::__private::Option::is_some(&m_sectionIndex) {
407                                    return _serde::__private::Err(
408                                        <__A::Error as _serde::de::Error>::duplicate_field(
409                                            "sectionIndex",
410                                        ),
411                                    );
412                                }
413                                m_sectionIndex = _serde::__private::Some(
414                                    match __A::next_value::<i32>(&mut __map) {
415                                        _serde::__private::Ok(__val) => __val,
416                                        _serde::__private::Err(__err) => {
417                                            return _serde::__private::Err(__err);
418                                        }
419                                    },
420                                );
421                            }
422                            _ => {}
423                        }
424                    }
425                    __A::pad(&mut __map, 0usize, 4usize)?;
426                    let m_primitiveType = match m_primitiveType {
427                        _serde::__private::Some(__field) => __field,
428                        _serde::__private::None => {
429                            return _serde::__private::Err(
430                                <__A::Error as _serde::de::Error>::missing_field(
431                                    "primitiveType",
432                                ),
433                            );
434                        }
435                    };
436                    let m_numPrimitives = match m_numPrimitives {
437                        _serde::__private::Some(__field) => __field,
438                        _serde::__private::None => {
439                            return _serde::__private::Err(
440                                <__A::Error as _serde::de::Error>::missing_field(
441                                    "numPrimitives",
442                                ),
443                            );
444                        }
445                    };
446                    let m_numIndices = match m_numIndices {
447                        _serde::__private::Some(__field) => __field,
448                        _serde::__private::None => {
449                            return _serde::__private::Err(
450                                <__A::Error as _serde::de::Error>::missing_field(
451                                    "numIndices",
452                                ),
453                            );
454                        }
455                    };
456                    let m_vertexStartIndex = match m_vertexStartIndex {
457                        _serde::__private::Some(__field) => __field,
458                        _serde::__private::None => {
459                            return _serde::__private::Err(
460                                <__A::Error as _serde::de::Error>::missing_field(
461                                    "vertexStartIndex",
462                                ),
463                            );
464                        }
465                    };
466                    let m_transformIndex = match m_transformIndex {
467                        _serde::__private::Some(__field) => __field,
468                        _serde::__private::None => {
469                            return _serde::__private::Err(
470                                <__A::Error as _serde::de::Error>::missing_field(
471                                    "transformIndex",
472                                ),
473                            );
474                        }
475                    };
476                    let m_indexType = match m_indexType {
477                        _serde::__private::Some(__field) => __field,
478                        _serde::__private::None => {
479                            return _serde::__private::Err(
480                                <__A::Error as _serde::de::Error>::missing_field(
481                                    "indexType",
482                                ),
483                            );
484                        }
485                    };
486                    let m_indices = match m_indices {
487                        _serde::__private::Some(__field) => __field,
488                        _serde::__private::None => {
489                            return _serde::__private::Err(
490                                <__A::Error as _serde::de::Error>::missing_field("indices"),
491                            );
492                        }
493                    };
494                    let m_vertexBuffer = match m_vertexBuffer {
495                        _serde::__private::Some(__field) => __field,
496                        _serde::__private::None => {
497                            return _serde::__private::Err(
498                                <__A::Error as _serde::de::Error>::missing_field(
499                                    "vertexBuffer",
500                                ),
501                            );
502                        }
503                    };
504                    let m_material = match m_material {
505                        _serde::__private::Some(__field) => __field,
506                        _serde::__private::None => {
507                            return _serde::__private::Err(
508                                <__A::Error as _serde::de::Error>::missing_field("material"),
509                            );
510                        }
511                    };
512                    let m_sectionIndex = match m_sectionIndex {
513                        _serde::__private::Some(__field) => __field,
514                        _serde::__private::None => {
515                            return _serde::__private::Err(
516                                <__A::Error as _serde::de::Error>::missing_field(
517                                    "sectionIndex",
518                                ),
519                            );
520                        }
521                    };
522                    _serde::__private::Ok(hkMeshSection {
523                        __ptr,
524                        m_primitiveType,
525                        m_numPrimitives,
526                        m_numIndices,
527                        m_vertexStartIndex,
528                        m_transformIndex,
529                        m_indexType,
530                        m_indices,
531                        m_vertexBuffer,
532                        m_material,
533                        m_sectionIndex,
534                    })
535                }
536                #[allow(clippy::manual_unwrap_or_default)]
537                fn visit_struct<__A>(
538                    self,
539                    mut __map: __A,
540                ) -> _serde::__private::Result<Self::Value, __A::Error>
541                where
542                    __A: _serde::de::MapAccess<'de>,
543                {
544                    let mut m_primitiveType: _serde::__private::Option<PrimitiveType> = _serde::__private::None;
545                    let mut m_numPrimitives: _serde::__private::Option<i32> = _serde::__private::None;
546                    let mut m_numIndices: _serde::__private::Option<i32> = _serde::__private::None;
547                    let mut m_vertexStartIndex: _serde::__private::Option<i32> = _serde::__private::None;
548                    let mut m_transformIndex: _serde::__private::Option<i32> = _serde::__private::None;
549                    let mut m_indexType: _serde::__private::Option<
550                        MeshSectionIndexType,
551                    > = _serde::__private::None;
552                    let mut m_vertexBuffer: _serde::__private::Option<Pointer> = _serde::__private::None;
553                    let mut m_material: _serde::__private::Option<Pointer> = _serde::__private::None;
554                    let mut m_sectionIndex: _serde::__private::Option<i32> = _serde::__private::None;
555                    while let _serde::__private::Some(__key) = {
556                        __A::next_key::<__Field>(&mut __map)?
557                    } {
558                        match __key {
559                            __Field::m_primitiveType => {
560                                #[cfg(
561                                    any(feature = "strict", feature = "ignore_duplicates")
562                                )]
563                                if _serde::__private::Option::is_some(&m_primitiveType) {
564                                    #[cfg(feature = "ignore_duplicates")]
565                                    {
566                                        __A::skip_value(&mut __map)?;
567                                        continue;
568                                    }
569                                    #[cfg(feature = "strict")]
570                                    return _serde::__private::Err(
571                                        <__A::Error as _serde::de::Error>::duplicate_field(
572                                            "primitiveType",
573                                        ),
574                                    );
575                                }
576                                m_primitiveType = _serde::__private::Some(
577                                    match __A::next_value::<PrimitiveType>(&mut __map) {
578                                        _serde::__private::Ok(__val) => __val,
579                                        _serde::__private::Err(__err) => {
580                                            return _serde::__private::Err(__err);
581                                        }
582                                    },
583                                );
584                            }
585                            __Field::m_numPrimitives => {
586                                #[cfg(
587                                    any(feature = "strict", feature = "ignore_duplicates")
588                                )]
589                                if _serde::__private::Option::is_some(&m_numPrimitives) {
590                                    #[cfg(feature = "ignore_duplicates")]
591                                    {
592                                        __A::skip_value(&mut __map)?;
593                                        continue;
594                                    }
595                                    #[cfg(feature = "strict")]
596                                    return _serde::__private::Err(
597                                        <__A::Error as _serde::de::Error>::duplicate_field(
598                                            "numPrimitives",
599                                        ),
600                                    );
601                                }
602                                m_numPrimitives = _serde::__private::Some(
603                                    match __A::next_value::<i32>(&mut __map) {
604                                        _serde::__private::Ok(__val) => __val,
605                                        _serde::__private::Err(__err) => {
606                                            return _serde::__private::Err(__err);
607                                        }
608                                    },
609                                );
610                            }
611                            __Field::m_numIndices => {
612                                #[cfg(
613                                    any(feature = "strict", feature = "ignore_duplicates")
614                                )]
615                                if _serde::__private::Option::is_some(&m_numIndices) {
616                                    #[cfg(feature = "ignore_duplicates")]
617                                    {
618                                        __A::skip_value(&mut __map)?;
619                                        continue;
620                                    }
621                                    #[cfg(feature = "strict")]
622                                    return _serde::__private::Err(
623                                        <__A::Error as _serde::de::Error>::duplicate_field(
624                                            "numIndices",
625                                        ),
626                                    );
627                                }
628                                m_numIndices = _serde::__private::Some(
629                                    match __A::next_value::<i32>(&mut __map) {
630                                        _serde::__private::Ok(__val) => __val,
631                                        _serde::__private::Err(__err) => {
632                                            return _serde::__private::Err(__err);
633                                        }
634                                    },
635                                );
636                            }
637                            __Field::m_vertexStartIndex => {
638                                #[cfg(
639                                    any(feature = "strict", feature = "ignore_duplicates")
640                                )]
641                                if _serde::__private::Option::is_some(&m_vertexStartIndex) {
642                                    #[cfg(feature = "ignore_duplicates")]
643                                    {
644                                        __A::skip_value(&mut __map)?;
645                                        continue;
646                                    }
647                                    #[cfg(feature = "strict")]
648                                    return _serde::__private::Err(
649                                        <__A::Error as _serde::de::Error>::duplicate_field(
650                                            "vertexStartIndex",
651                                        ),
652                                    );
653                                }
654                                m_vertexStartIndex = _serde::__private::Some(
655                                    match __A::next_value::<i32>(&mut __map) {
656                                        _serde::__private::Ok(__val) => __val,
657                                        _serde::__private::Err(__err) => {
658                                            return _serde::__private::Err(__err);
659                                        }
660                                    },
661                                );
662                            }
663                            __Field::m_transformIndex => {
664                                #[cfg(
665                                    any(feature = "strict", feature = "ignore_duplicates")
666                                )]
667                                if _serde::__private::Option::is_some(&m_transformIndex) {
668                                    #[cfg(feature = "ignore_duplicates")]
669                                    {
670                                        __A::skip_value(&mut __map)?;
671                                        continue;
672                                    }
673                                    #[cfg(feature = "strict")]
674                                    return _serde::__private::Err(
675                                        <__A::Error as _serde::de::Error>::duplicate_field(
676                                            "transformIndex",
677                                        ),
678                                    );
679                                }
680                                m_transformIndex = _serde::__private::Some(
681                                    match __A::next_value::<i32>(&mut __map) {
682                                        _serde::__private::Ok(__val) => __val,
683                                        _serde::__private::Err(__err) => {
684                                            return _serde::__private::Err(__err);
685                                        }
686                                    },
687                                );
688                            }
689                            __Field::m_indexType => {
690                                #[cfg(
691                                    any(feature = "strict", feature = "ignore_duplicates")
692                                )]
693                                if _serde::__private::Option::is_some(&m_indexType) {
694                                    #[cfg(feature = "ignore_duplicates")]
695                                    {
696                                        __A::skip_value(&mut __map)?;
697                                        continue;
698                                    }
699                                    #[cfg(feature = "strict")]
700                                    return _serde::__private::Err(
701                                        <__A::Error as _serde::de::Error>::duplicate_field(
702                                            "indexType",
703                                        ),
704                                    );
705                                }
706                                m_indexType = _serde::__private::Some(
707                                    match __A::next_value::<MeshSectionIndexType>(&mut __map) {
708                                        _serde::__private::Ok(__val) => __val,
709                                        _serde::__private::Err(__err) => {
710                                            return _serde::__private::Err(__err);
711                                        }
712                                    },
713                                );
714                            }
715                            __Field::m_vertexBuffer => {
716                                #[cfg(
717                                    any(feature = "strict", feature = "ignore_duplicates")
718                                )]
719                                if _serde::__private::Option::is_some(&m_vertexBuffer) {
720                                    #[cfg(feature = "ignore_duplicates")]
721                                    {
722                                        __A::skip_value(&mut __map)?;
723                                        continue;
724                                    }
725                                    #[cfg(feature = "strict")]
726                                    return _serde::__private::Err(
727                                        <__A::Error as _serde::de::Error>::duplicate_field(
728                                            "vertexBuffer",
729                                        ),
730                                    );
731                                }
732                                m_vertexBuffer = _serde::__private::Some(
733                                    match __A::next_value::<Pointer>(&mut __map) {
734                                        _serde::__private::Ok(__val) => __val,
735                                        _serde::__private::Err(__err) => {
736                                            return _serde::__private::Err(__err);
737                                        }
738                                    },
739                                );
740                            }
741                            __Field::m_material => {
742                                #[cfg(
743                                    any(feature = "strict", feature = "ignore_duplicates")
744                                )]
745                                if _serde::__private::Option::is_some(&m_material) {
746                                    #[cfg(feature = "ignore_duplicates")]
747                                    {
748                                        __A::skip_value(&mut __map)?;
749                                        continue;
750                                    }
751                                    #[cfg(feature = "strict")]
752                                    return _serde::__private::Err(
753                                        <__A::Error as _serde::de::Error>::duplicate_field(
754                                            "material",
755                                        ),
756                                    );
757                                }
758                                m_material = _serde::__private::Some(
759                                    match __A::next_value::<Pointer>(&mut __map) {
760                                        _serde::__private::Ok(__val) => __val,
761                                        _serde::__private::Err(__err) => {
762                                            return _serde::__private::Err(__err);
763                                        }
764                                    },
765                                );
766                            }
767                            __Field::m_sectionIndex => {
768                                #[cfg(
769                                    any(feature = "strict", feature = "ignore_duplicates")
770                                )]
771                                if _serde::__private::Option::is_some(&m_sectionIndex) {
772                                    #[cfg(feature = "ignore_duplicates")]
773                                    {
774                                        __A::skip_value(&mut __map)?;
775                                        continue;
776                                    }
777                                    #[cfg(feature = "strict")]
778                                    return _serde::__private::Err(
779                                        <__A::Error as _serde::de::Error>::duplicate_field(
780                                            "sectionIndex",
781                                        ),
782                                    );
783                                }
784                                m_sectionIndex = _serde::__private::Some(
785                                    match __A::next_value::<i32>(&mut __map) {
786                                        _serde::__private::Ok(__val) => __val,
787                                        _serde::__private::Err(__err) => {
788                                            return _serde::__private::Err(__err);
789                                        }
790                                    },
791                                );
792                            }
793                            _ => __A::skip_value(&mut __map)?,
794                        }
795                    }
796                    let m_primitiveType = match m_primitiveType {
797                        _serde::__private::Some(__field) => __field,
798                        _serde::__private::None => {
799                            #[cfg(feature = "strict")]
800                            return _serde::__private::Err(
801                                <__A::Error as _serde::de::Error>::missing_field(
802                                    "primitiveType",
803                                ),
804                            );
805                            #[cfg(not(feature = "strict"))] Default::default()
806                        }
807                    };
808                    let m_numPrimitives = match m_numPrimitives {
809                        _serde::__private::Some(__field) => __field,
810                        _serde::__private::None => {
811                            #[cfg(feature = "strict")]
812                            return _serde::__private::Err(
813                                <__A::Error as _serde::de::Error>::missing_field(
814                                    "numPrimitives",
815                                ),
816                            );
817                            #[cfg(not(feature = "strict"))] Default::default()
818                        }
819                    };
820                    let m_numIndices = match m_numIndices {
821                        _serde::__private::Some(__field) => __field,
822                        _serde::__private::None => {
823                            #[cfg(feature = "strict")]
824                            return _serde::__private::Err(
825                                <__A::Error as _serde::de::Error>::missing_field(
826                                    "numIndices",
827                                ),
828                            );
829                            #[cfg(not(feature = "strict"))] Default::default()
830                        }
831                    };
832                    let m_vertexStartIndex = match m_vertexStartIndex {
833                        _serde::__private::Some(__field) => __field,
834                        _serde::__private::None => {
835                            #[cfg(feature = "strict")]
836                            return _serde::__private::Err(
837                                <__A::Error as _serde::de::Error>::missing_field(
838                                    "vertexStartIndex",
839                                ),
840                            );
841                            #[cfg(not(feature = "strict"))] Default::default()
842                        }
843                    };
844                    let m_transformIndex = match m_transformIndex {
845                        _serde::__private::Some(__field) => __field,
846                        _serde::__private::None => {
847                            #[cfg(feature = "strict")]
848                            return _serde::__private::Err(
849                                <__A::Error as _serde::de::Error>::missing_field(
850                                    "transformIndex",
851                                ),
852                            );
853                            #[cfg(not(feature = "strict"))] Default::default()
854                        }
855                    };
856                    let m_indexType = match m_indexType {
857                        _serde::__private::Some(__field) => __field,
858                        _serde::__private::None => {
859                            #[cfg(feature = "strict")]
860                            return _serde::__private::Err(
861                                <__A::Error as _serde::de::Error>::missing_field(
862                                    "indexType",
863                                ),
864                            );
865                            #[cfg(not(feature = "strict"))] Default::default()
866                        }
867                    };
868                    let m_vertexBuffer = match m_vertexBuffer {
869                        _serde::__private::Some(__field) => __field,
870                        _serde::__private::None => {
871                            #[cfg(feature = "strict")]
872                            return _serde::__private::Err(
873                                <__A::Error as _serde::de::Error>::missing_field(
874                                    "vertexBuffer",
875                                ),
876                            );
877                            #[cfg(not(feature = "strict"))] Default::default()
878                        }
879                    };
880                    let m_material = match m_material {
881                        _serde::__private::Some(__field) => __field,
882                        _serde::__private::None => {
883                            #[cfg(feature = "strict")]
884                            return _serde::__private::Err(
885                                <__A::Error as _serde::de::Error>::missing_field("material"),
886                            );
887                            #[cfg(not(feature = "strict"))] Default::default()
888                        }
889                    };
890                    let m_sectionIndex = match m_sectionIndex {
891                        _serde::__private::Some(__field) => __field,
892                        _serde::__private::None => {
893                            #[cfg(feature = "strict")]
894                            return _serde::__private::Err(
895                                <__A::Error as _serde::de::Error>::missing_field(
896                                    "sectionIndex",
897                                ),
898                            );
899                            #[cfg(not(feature = "strict"))] Default::default()
900                        }
901                    };
902                    let __ptr = __A::class_ptr(&mut __map);
903                    _serde::__private::Ok(hkMeshSection {
904                        __ptr,
905                        m_primitiveType,
906                        m_numPrimitives,
907                        m_numIndices,
908                        m_vertexStartIndex,
909                        m_transformIndex,
910                        m_indexType,
911                        m_vertexBuffer,
912                        m_material,
913                        m_sectionIndex,
914                        ..Default::default()
915                    })
916                }
917            }
918            const FIELDS: &[&str] = &[
919                "primitiveType",
920                "numPrimitives",
921                "numIndices",
922                "vertexStartIndex",
923                "transformIndex",
924                "indexType",
925                "indices",
926                "vertexBuffer",
927                "material",
928                "sectionIndex",
929            ];
930            _serde::Deserializer::deserialize_struct(
931                deserializer,
932                "hkMeshSection",
933                FIELDS,
934                __hkMeshSectionVisitor {
935                    marker: _serde::__private::PhantomData::<hkMeshSection>,
936                    lifetime: _serde::__private::PhantomData,
937                },
938            )
939        }
940    }
941};
942/// # C++ Info
943/// - name: `MeshSectionIndexType`(ctype: `hkEnum<MeshSectionIndexType, hkUint8>`)
944#[allow(non_upper_case_globals, non_snake_case)]
945#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
946#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
947#[derive(
948    Debug,
949    Clone,
950    Default,
951    PartialEq,
952    Eq,
953    PartialOrd,
954    Ord,
955    num_derive::ToPrimitive,
956    num_derive::FromPrimitive,
957)]
958pub enum MeshSectionIndexType {
959    #[default]
960    INDEX_TYPE_NONE = 0isize,
961    INDEX_TYPE_UINT16 = 1isize,
962    INDEX_TYPE_UINT32 = 2isize,
963}
964/// # C++ Info
965/// - name: `PrimitiveType`(ctype: `hkEnum<PrimitiveType, hkUint8>`)
966#[allow(non_upper_case_globals, non_snake_case)]
967#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
968#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
969#[derive(
970    Debug,
971    Clone,
972    Default,
973    PartialEq,
974    Eq,
975    PartialOrd,
976    Ord,
977    num_derive::ToPrimitive,
978    num_derive::FromPrimitive,
979)]
980pub enum PrimitiveType {
981    #[default]
982    PRIMITIVE_TYPE_UNKNOWN = 0isize,
983    PRIMITIVE_TYPE_POINT_LIST = 1isize,
984    PRIMITIVE_TYPE_LINE_LIST = 2isize,
985    PRIMITIVE_TYPE_TRIANGLE_LIST = 3isize,
986    PRIMITIVE_TYPE_TRIANGLE_STRIP = 4isize,
987}
988const _: () = {
989    use havok_serde as __serde;
990    impl __serde::Serialize for MeshSectionIndexType {
991        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
992        where
993            S: __serde::ser::Serializer,
994        {
995            let mut __serializer = __serializer.serialize_enum_flags()?;
996            match self {
997                Self::INDEX_TYPE_NONE => {
998                    __serializer.serialize_field("INDEX_TYPE_NONE", &0u64)
999                }
1000                Self::INDEX_TYPE_UINT16 => {
1001                    __serializer.serialize_field("INDEX_TYPE_UINT16", &1u64)
1002                }
1003                Self::INDEX_TYPE_UINT32 => {
1004                    __serializer.serialize_field("INDEX_TYPE_UINT32", &2u64)
1005                }
1006            }?;
1007            use num_traits::ToPrimitive as _;
1008            let num = self
1009                .to_u8()
1010                .ok_or(S::Error::custom("Failed enum MeshSectionIndexType to_u8"))?;
1011            __serializer.serialize_bits(&num)?;
1012            __serializer.end()
1013        }
1014    }
1015};
1016const _: () = {
1017    use havok_serde as __serde;
1018    impl __serde::Serialize for PrimitiveType {
1019        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1020        where
1021            S: __serde::ser::Serializer,
1022        {
1023            let mut __serializer = __serializer.serialize_enum_flags()?;
1024            match self {
1025                Self::PRIMITIVE_TYPE_UNKNOWN => {
1026                    __serializer.serialize_field("PRIMITIVE_TYPE_UNKNOWN", &0u64)
1027                }
1028                Self::PRIMITIVE_TYPE_POINT_LIST => {
1029                    __serializer.serialize_field("PRIMITIVE_TYPE_POINT_LIST", &1u64)
1030                }
1031                Self::PRIMITIVE_TYPE_LINE_LIST => {
1032                    __serializer.serialize_field("PRIMITIVE_TYPE_LINE_LIST", &2u64)
1033                }
1034                Self::PRIMITIVE_TYPE_TRIANGLE_LIST => {
1035                    __serializer.serialize_field("PRIMITIVE_TYPE_TRIANGLE_LIST", &3u64)
1036                }
1037                Self::PRIMITIVE_TYPE_TRIANGLE_STRIP => {
1038                    __serializer.serialize_field("PRIMITIVE_TYPE_TRIANGLE_STRIP", &4u64)
1039                }
1040            }?;
1041            use num_traits::ToPrimitive as _;
1042            let num = self
1043                .to_u8()
1044                .ok_or(S::Error::custom("Failed enum PrimitiveType to_u8"))?;
1045            __serializer.serialize_bits(&num)?;
1046            __serializer.end()
1047        }
1048    }
1049};
1050#[doc(hidden)]
1051#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1052const _: () = {
1053    #[allow(unused_extern_crates, clippy::useless_attribute)]
1054    extern crate havok_serde as _serde;
1055    #[automatically_derived]
1056    impl<'de> _serde::Deserialize<'de> for MeshSectionIndexType {
1057        fn deserialize<__D>(
1058            __deserializer: __D,
1059        ) -> _serde::__private::Result<Self, __D::Error>
1060        where
1061            __D: _serde::Deserializer<'de>,
1062        {
1063            #[allow(non_camel_case_types)]
1064            #[doc(hidden)]
1065            enum __Field {
1066                __field0,
1067                __field1,
1068                __field2,
1069            }
1070            #[doc(hidden)]
1071            struct __FieldVisitor;
1072            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1073                type Value = __Field;
1074                fn expecting(
1075                    &self,
1076                    __formatter: &mut _serde::__private::Formatter,
1077                ) -> _serde::__private::fmt::Result {
1078                    _serde::__private::Formatter::write_str(
1079                        __formatter,
1080                        "variant identifier",
1081                    )
1082                }
1083                fn visit_uint8<__E>(
1084                    self,
1085                    __value: u8,
1086                ) -> _serde::__private::Result<Self::Value, __E>
1087                where
1088                    __E: _serde::de::Error,
1089                {
1090                    match __value {
1091                        0u8 => _serde::__private::Ok(__Field::__field0),
1092                        1u8 => _serde::__private::Ok(__Field::__field1),
1093                        2u8 => _serde::__private::Ok(__Field::__field2),
1094                        _ => {
1095                            _serde::__private::Err(
1096                                _serde::de::Error::invalid_value(
1097                                    _serde::de::Unexpected::Uint8(__value),
1098                                    &"value(u8) of variant is one of 0, 1, 2",
1099                                ),
1100                            )
1101                        }
1102                    }
1103                }
1104                fn visit_stringptr<__E>(
1105                    self,
1106                    __value: StringPtr<'de>,
1107                ) -> _serde::__private::Result<Self::Value, __E>
1108                where
1109                    __E: _serde::de::Error,
1110                {
1111                    if let Some(__value) = __value.into_inner() {
1112                        match __value.as_ref() {
1113                            v if v == "0"
1114                                || v.eq_ignore_ascii_case("INDEX_TYPE_NONE") => {
1115                                _serde::__private::Ok(__Field::__field0)
1116                            }
1117                            v if v == "1"
1118                                || v.eq_ignore_ascii_case("INDEX_TYPE_UINT16") => {
1119                                _serde::__private::Ok(__Field::__field1)
1120                            }
1121                            v if v == "2"
1122                                || v.eq_ignore_ascii_case("INDEX_TYPE_UINT32") => {
1123                                _serde::__private::Ok(__Field::__field2)
1124                            }
1125                            _ => {
1126                                _serde::__private::Err(
1127                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1128                                )
1129                            }
1130                        }
1131                    } else {
1132                        _serde::__private::Err(
1133                            _serde::de::Error::unknown_variant("None", VARIANTS),
1134                        )
1135                    }
1136                }
1137            }
1138            impl<'de> _serde::Deserialize<'de> for __Field {
1139                #[inline]
1140                fn deserialize<__D>(
1141                    __deserializer: __D,
1142                ) -> _serde::__private::Result<Self, __D::Error>
1143                where
1144                    __D: _serde::Deserializer<'de>,
1145                {
1146                    _serde::Deserializer::deserialize_identifier(
1147                        __deserializer,
1148                        _serde::de::ReadEnumSize::Uint8,
1149                        __FieldVisitor,
1150                    )
1151                }
1152            }
1153            #[doc(hidden)]
1154            struct __Visitor<'de> {
1155                marker: _serde::__private::PhantomData<MeshSectionIndexType>,
1156                lifetime: _serde::__private::PhantomData<&'de ()>,
1157            }
1158            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1159                type Value = MeshSectionIndexType;
1160                fn expecting(
1161                    &self,
1162                    __formatter: &mut _serde::__private::Formatter,
1163                ) -> _serde::__private::fmt::Result {
1164                    _serde::__private::Formatter::write_str(
1165                        __formatter,
1166                        "enum MeshSectionIndexType",
1167                    )
1168                }
1169                fn visit_enum<__A>(
1170                    self,
1171                    __data: __A,
1172                ) -> _serde::__private::Result<Self::Value, __A::Error>
1173                where
1174                    __A: _serde::de::EnumAccess<'de>,
1175                {
1176                    match _serde::de::EnumAccess::variant(__data)? {
1177                        (__Field::__field0, __variant) => {
1178                            _serde::de::VariantAccess::unit_variant(__variant)?;
1179                            _serde::__private::Ok(MeshSectionIndexType::INDEX_TYPE_NONE)
1180                        }
1181                        (__Field::__field1, __variant) => {
1182                            _serde::de::VariantAccess::unit_variant(__variant)?;
1183                            _serde::__private::Ok(
1184                                MeshSectionIndexType::INDEX_TYPE_UINT16,
1185                            )
1186                        }
1187                        (__Field::__field2, __variant) => {
1188                            _serde::de::VariantAccess::unit_variant(__variant)?;
1189                            _serde::__private::Ok(
1190                                MeshSectionIndexType::INDEX_TYPE_UINT32,
1191                            )
1192                        }
1193                    }
1194                }
1195            }
1196            #[doc(hidden)]
1197            const VARIANTS: &'static [&'static str] = &[
1198                "INDEX_TYPE_NONE",
1199                "INDEX_TYPE_UINT16",
1200                "INDEX_TYPE_UINT32",
1201            ];
1202            _serde::Deserializer::deserialize_enum(
1203                __deserializer,
1204                "MeshSectionIndexType",
1205                VARIANTS,
1206                __Visitor {
1207                    marker: _serde::__private::PhantomData::<MeshSectionIndexType>,
1208                    lifetime: _serde::__private::PhantomData,
1209                },
1210            )
1211        }
1212    }
1213};
1214#[doc(hidden)]
1215#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1216const _: () = {
1217    #[allow(unused_extern_crates, clippy::useless_attribute)]
1218    extern crate havok_serde as _serde;
1219    #[automatically_derived]
1220    impl<'de> _serde::Deserialize<'de> for PrimitiveType {
1221        fn deserialize<__D>(
1222            __deserializer: __D,
1223        ) -> _serde::__private::Result<Self, __D::Error>
1224        where
1225            __D: _serde::Deserializer<'de>,
1226        {
1227            #[allow(non_camel_case_types)]
1228            #[doc(hidden)]
1229            enum __Field {
1230                __field0,
1231                __field1,
1232                __field2,
1233                __field3,
1234                __field4,
1235            }
1236            #[doc(hidden)]
1237            struct __FieldVisitor;
1238            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1239                type Value = __Field;
1240                fn expecting(
1241                    &self,
1242                    __formatter: &mut _serde::__private::Formatter,
1243                ) -> _serde::__private::fmt::Result {
1244                    _serde::__private::Formatter::write_str(
1245                        __formatter,
1246                        "variant identifier",
1247                    )
1248                }
1249                fn visit_uint8<__E>(
1250                    self,
1251                    __value: u8,
1252                ) -> _serde::__private::Result<Self::Value, __E>
1253                where
1254                    __E: _serde::de::Error,
1255                {
1256                    match __value {
1257                        0u8 => _serde::__private::Ok(__Field::__field0),
1258                        1u8 => _serde::__private::Ok(__Field::__field1),
1259                        2u8 => _serde::__private::Ok(__Field::__field2),
1260                        3u8 => _serde::__private::Ok(__Field::__field3),
1261                        4u8 => _serde::__private::Ok(__Field::__field4),
1262                        _ => {
1263                            _serde::__private::Err(
1264                                _serde::de::Error::invalid_value(
1265                                    _serde::de::Unexpected::Uint8(__value),
1266                                    &"value(u8) of variant is one of 0, 1, 2, 3, 4",
1267                                ),
1268                            )
1269                        }
1270                    }
1271                }
1272                fn visit_stringptr<__E>(
1273                    self,
1274                    __value: StringPtr<'de>,
1275                ) -> _serde::__private::Result<Self::Value, __E>
1276                where
1277                    __E: _serde::de::Error,
1278                {
1279                    if let Some(__value) = __value.into_inner() {
1280                        match __value.as_ref() {
1281                            v if v == "0"
1282                                || v.eq_ignore_ascii_case("PRIMITIVE_TYPE_UNKNOWN") => {
1283                                _serde::__private::Ok(__Field::__field0)
1284                            }
1285                            v if v == "1"
1286                                || v.eq_ignore_ascii_case("PRIMITIVE_TYPE_POINT_LIST") => {
1287                                _serde::__private::Ok(__Field::__field1)
1288                            }
1289                            v if v == "2"
1290                                || v.eq_ignore_ascii_case("PRIMITIVE_TYPE_LINE_LIST") => {
1291                                _serde::__private::Ok(__Field::__field2)
1292                            }
1293                            v if v == "3"
1294                                || v
1295                                    .eq_ignore_ascii_case("PRIMITIVE_TYPE_TRIANGLE_LIST") => {
1296                                _serde::__private::Ok(__Field::__field3)
1297                            }
1298                            v if v == "4"
1299                                || v
1300                                    .eq_ignore_ascii_case("PRIMITIVE_TYPE_TRIANGLE_STRIP") => {
1301                                _serde::__private::Ok(__Field::__field4)
1302                            }
1303                            _ => {
1304                                _serde::__private::Err(
1305                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1306                                )
1307                            }
1308                        }
1309                    } else {
1310                        _serde::__private::Err(
1311                            _serde::de::Error::unknown_variant("None", VARIANTS),
1312                        )
1313                    }
1314                }
1315            }
1316            impl<'de> _serde::Deserialize<'de> for __Field {
1317                #[inline]
1318                fn deserialize<__D>(
1319                    __deserializer: __D,
1320                ) -> _serde::__private::Result<Self, __D::Error>
1321                where
1322                    __D: _serde::Deserializer<'de>,
1323                {
1324                    _serde::Deserializer::deserialize_identifier(
1325                        __deserializer,
1326                        _serde::de::ReadEnumSize::Uint8,
1327                        __FieldVisitor,
1328                    )
1329                }
1330            }
1331            #[doc(hidden)]
1332            struct __Visitor<'de> {
1333                marker: _serde::__private::PhantomData<PrimitiveType>,
1334                lifetime: _serde::__private::PhantomData<&'de ()>,
1335            }
1336            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1337                type Value = PrimitiveType;
1338                fn expecting(
1339                    &self,
1340                    __formatter: &mut _serde::__private::Formatter,
1341                ) -> _serde::__private::fmt::Result {
1342                    _serde::__private::Formatter::write_str(
1343                        __formatter,
1344                        "enum PrimitiveType",
1345                    )
1346                }
1347                fn visit_enum<__A>(
1348                    self,
1349                    __data: __A,
1350                ) -> _serde::__private::Result<Self::Value, __A::Error>
1351                where
1352                    __A: _serde::de::EnumAccess<'de>,
1353                {
1354                    match _serde::de::EnumAccess::variant(__data)? {
1355                        (__Field::__field0, __variant) => {
1356                            _serde::de::VariantAccess::unit_variant(__variant)?;
1357                            _serde::__private::Ok(PrimitiveType::PRIMITIVE_TYPE_UNKNOWN)
1358                        }
1359                        (__Field::__field1, __variant) => {
1360                            _serde::de::VariantAccess::unit_variant(__variant)?;
1361                            _serde::__private::Ok(
1362                                PrimitiveType::PRIMITIVE_TYPE_POINT_LIST,
1363                            )
1364                        }
1365                        (__Field::__field2, __variant) => {
1366                            _serde::de::VariantAccess::unit_variant(__variant)?;
1367                            _serde::__private::Ok(
1368                                PrimitiveType::PRIMITIVE_TYPE_LINE_LIST,
1369                            )
1370                        }
1371                        (__Field::__field3, __variant) => {
1372                            _serde::de::VariantAccess::unit_variant(__variant)?;
1373                            _serde::__private::Ok(
1374                                PrimitiveType::PRIMITIVE_TYPE_TRIANGLE_LIST,
1375                            )
1376                        }
1377                        (__Field::__field4, __variant) => {
1378                            _serde::de::VariantAccess::unit_variant(__variant)?;
1379                            _serde::__private::Ok(
1380                                PrimitiveType::PRIMITIVE_TYPE_TRIANGLE_STRIP,
1381                            )
1382                        }
1383                    }
1384                }
1385            }
1386            #[doc(hidden)]
1387            const VARIANTS: &'static [&'static str] = &[
1388                "PRIMITIVE_TYPE_UNKNOWN",
1389                "PRIMITIVE_TYPE_POINT_LIST",
1390                "PRIMITIVE_TYPE_LINE_LIST",
1391                "PRIMITIVE_TYPE_TRIANGLE_LIST",
1392                "PRIMITIVE_TYPE_TRIANGLE_STRIP",
1393            ];
1394            _serde::Deserializer::deserialize_enum(
1395                __deserializer,
1396                "PrimitiveType",
1397                VARIANTS,
1398                __Visitor {
1399                    marker: _serde::__private::PhantomData::<PrimitiveType>,
1400                    lifetime: _serde::__private::PhantomData,
1401                },
1402            )
1403        }
1404    }
1405};