1use super::class_requires::*;
2use super::*;
3#[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 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
36 #[cfg_attr(feature = "serde", serde(rename = "type"))]
37 pub m_type: u8,
38 #[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 #[cfg_attr(feature = "json_schema", schemars(rename = "keyboardKey"))]
51 #[cfg_attr(feature = "serde", serde(rename = "keyboardKey"))]
52 pub m_keyboardKey: KeyboardKey,
53 #[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 #[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#[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#[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};