havok_classes/generated/
hkpFirstPersonGun_.rs

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