havok_classes/generated/
hkxIndexBuffer_.rs

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