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 hkpMountedBallGun<'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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkpBallGun<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "position"))]
36 #[cfg_attr(feature = "serde", serde(rename = "position"))]
37 pub m_position: Vector4,
38}
39const _: () = {
40 use havok_serde as _serde;
41 impl<'a> _serde::HavokClass for hkpMountedBallGun<'a> {
42 #[inline]
43 fn name(&self) -> &'static str {
44 "hkpMountedBallGun"
45 }
46 #[inline]
47 fn signature(&self) -> _serde::__private::Signature {
48 _serde::__private::Signature::new(0x6791ffce)
49 }
50 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
51 fn deps_indexes(&self) -> Vec<usize> {
52 let mut v = Vec::new();
53 v.extend(self.parent.parent.m_listeners.iter().map(|ptr| ptr.get()));
54 v.push(self.parent.m_addedBodies.get());
55 v
56 }
57 }
58 impl<'a> _serde::Serialize for hkpMountedBallGun<'a> {
59 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
60 where
61 S: _serde::ser::Serializer,
62 {
63 let class_meta = self
64 .__ptr
65 .map(|name| (name, _serde::__private::Signature::new(0x6791ffce)));
66 let mut serializer = __serializer
67 .serialize_struct("hkpMountedBallGun", class_meta, (112u64, 128u64))?;
68 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
69 serializer
70 .skip_field(
71 "memSizeAndFlags",
72 &self.parent.parent.parent.m_memSizeAndFlags,
73 )?;
74 serializer
75 .skip_field(
76 "referenceCount",
77 &self.parent.parent.parent.m_referenceCount,
78 )?;
79 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
80 serializer.skip_field("type", &self.parent.parent.m_type)?;
81 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
82 serializer.serialize_field("name", &self.parent.parent.m_name)?;
83 serializer
84 .serialize_field("keyboardKey", &self.parent.parent.m_keyboardKey)?;
85 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
86 serializer
87 .skip_array_field(
88 "listeners",
89 &self.parent.parent.m_listeners,
90 TypeSize::NonPtr,
91 )?;
92 serializer.serialize_field("bulletRadius", &self.parent.m_bulletRadius)?;
93 serializer.serialize_field("bulletVelocity", &self.parent.m_bulletVelocity)?;
94 serializer.serialize_field("bulletMass", &self.parent.m_bulletMass)?;
95 serializer
96 .serialize_field("damageMultiplier", &self.parent.m_damageMultiplier)?;
97 serializer
98 .serialize_field("maxBulletsInWorld", &self.parent.m_maxBulletsInWorld)?;
99 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 4usize].as_slice())?;
100 serializer
101 .serialize_field(
102 "bulletOffsetFromCenter",
103 &self.parent.m_bulletOffsetFromCenter,
104 )?;
105 serializer.skip_field("addedBodies", &self.parent.m_addedBodies)?;
106 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
107 serializer.serialize_field("position", &self.m_position)?;
108 serializer.end()
109 }
110 }
111};
112#[doc(hidden)]
113#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
114const _: () = {
115 use havok_serde as _serde;
116 #[automatically_derived]
117 impl<'de> _serde::Deserialize<'de> for hkpMountedBallGun<'de> {
118 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
119 where
120 __D: _serde::Deserializer<'de>,
121 {
122 #[allow(non_camel_case_types)]
123 enum __Field {
124 m_name,
125 m_keyboardKey,
126 m_bulletRadius,
127 m_bulletVelocity,
128 m_bulletMass,
129 m_damageMultiplier,
130 m_maxBulletsInWorld,
131 m_bulletOffsetFromCenter,
132 m_position,
133 __ignore,
134 }
135 struct __FieldVisitor;
136 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
137 type Value = __Field;
138 fn expecting(
139 &self,
140 __formatter: &mut core::fmt::Formatter,
141 ) -> core::fmt::Result {
142 core::fmt::Formatter::write_str(__formatter, "field identifier")
143 }
144 #[allow(clippy::match_single_binding)]
146 #[allow(clippy::reversed_empty_ranges)]
147 #[allow(clippy::single_match)]
148 fn visit_key<__E>(
149 self,
150 __value: &str,
151 ) -> core::result::Result<Self::Value, __E>
152 where
153 __E: _serde::de::Error,
154 {
155 match __value {
156 "name" => Ok(__Field::m_name),
157 "keyboardKey" => Ok(__Field::m_keyboardKey),
158 "bulletRadius" => Ok(__Field::m_bulletRadius),
159 "bulletVelocity" => Ok(__Field::m_bulletVelocity),
160 "bulletMass" => Ok(__Field::m_bulletMass),
161 "damageMultiplier" => Ok(__Field::m_damageMultiplier),
162 "maxBulletsInWorld" => Ok(__Field::m_maxBulletsInWorld),
163 "bulletOffsetFromCenter" => Ok(__Field::m_bulletOffsetFromCenter),
164 "position" => Ok(__Field::m_position),
165 _ => Ok(__Field::__ignore),
166 }
167 }
168 }
169 impl<'de> _serde::Deserialize<'de> for __Field {
170 #[inline]
171 fn deserialize<__D>(
172 __deserializer: __D,
173 ) -> core::result::Result<Self, __D::Error>
174 where
175 __D: _serde::Deserializer<'de>,
176 {
177 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
178 }
179 }
180 struct __hkpMountedBallGunVisitor<'de> {
181 marker: _serde::__private::PhantomData<hkpMountedBallGun<'de>>,
182 lifetime: _serde::__private::PhantomData<&'de ()>,
183 }
184 #[allow(clippy::match_single_binding)]
185 #[allow(clippy::reversed_empty_ranges)]
186 #[allow(clippy::single_match)]
187 impl<'de> _serde::de::Visitor<'de> for __hkpMountedBallGunVisitor<'de> {
188 type Value = hkpMountedBallGun<'de>;
189 fn expecting(
190 &self,
191 __formatter: &mut core::fmt::Formatter,
192 ) -> core::fmt::Result {
193 core::fmt::Formatter::write_str(
194 __formatter,
195 "struct hkpMountedBallGun",
196 )
197 }
198 fn visit_struct_for_bytes<__A>(
199 self,
200 mut __map: __A,
201 ) -> _serde::__private::Result<Self::Value, __A::Error>
202 where
203 __A: _serde::de::MapAccess<'de>,
204 {
205 let __ptr = __A::class_ptr(&mut __map);
206 let parent = __A::parent_value(&mut __map)?;
207 let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
208 for i in 0..1usize {
209 match i {
210 0usize => {
211 if _serde::__private::Option::is_some(&m_position) {
212 return _serde::__private::Err(
213 <__A::Error as _serde::de::Error>::duplicate_field(
214 "position",
215 ),
216 );
217 }
218 m_position = _serde::__private::Some(
219 match __A::next_value::<Vector4>(&mut __map) {
220 _serde::__private::Ok(__val) => __val,
221 _serde::__private::Err(__err) => {
222 return _serde::__private::Err(__err);
223 }
224 },
225 );
226 }
227 _ => {}
228 }
229 }
230 let m_position = match m_position {
231 _serde::__private::Some(__field) => __field,
232 _serde::__private::None => {
233 return _serde::__private::Err(
234 <__A::Error as _serde::de::Error>::missing_field("position"),
235 );
236 }
237 };
238 _serde::__private::Ok(hkpMountedBallGun {
239 __ptr,
240 parent,
241 m_position,
242 })
243 }
244 #[allow(clippy::manual_unwrap_or_default)]
245 fn visit_struct<__A>(
246 self,
247 mut __map: __A,
248 ) -> _serde::__private::Result<Self::Value, __A::Error>
249 where
250 __A: _serde::de::MapAccess<'de>,
251 {
252 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
253 let mut m_keyboardKey: _serde::__private::Option<KeyboardKey> = _serde::__private::None;
254 let mut m_bulletRadius: _serde::__private::Option<f32> = _serde::__private::None;
255 let mut m_bulletVelocity: _serde::__private::Option<f32> = _serde::__private::None;
256 let mut m_bulletMass: _serde::__private::Option<f32> = _serde::__private::None;
257 let mut m_damageMultiplier: _serde::__private::Option<f32> = _serde::__private::None;
258 let mut m_maxBulletsInWorld: _serde::__private::Option<i32> = _serde::__private::None;
259 let mut m_bulletOffsetFromCenter: _serde::__private::Option<
260 Vector4,
261 > = _serde::__private::None;
262 let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
263 while let _serde::__private::Some(__key) = {
264 __A::next_key::<__Field>(&mut __map)?
265 } {
266 match __key {
267 __Field::m_name => {
268 #[cfg(
269 any(feature = "strict", feature = "ignore_duplicates")
270 )]
271 if _serde::__private::Option::is_some(&m_name) {
272 #[cfg(feature = "ignore_duplicates")]
273 {
274 __A::skip_value(&mut __map)?;
275 continue;
276 }
277 #[cfg(feature = "strict")]
278 return _serde::__private::Err(
279 <__A::Error as _serde::de::Error>::duplicate_field("name"),
280 );
281 }
282 m_name = _serde::__private::Some(
283 match __A::next_value::<StringPtr<'de>>(&mut __map) {
284 _serde::__private::Ok(__val) => __val,
285 _serde::__private::Err(__err) => {
286 return _serde::__private::Err(__err);
287 }
288 },
289 );
290 }
291 __Field::m_keyboardKey => {
292 #[cfg(
293 any(feature = "strict", feature = "ignore_duplicates")
294 )]
295 if _serde::__private::Option::is_some(&m_keyboardKey) {
296 #[cfg(feature = "ignore_duplicates")]
297 {
298 __A::skip_value(&mut __map)?;
299 continue;
300 }
301 #[cfg(feature = "strict")]
302 return _serde::__private::Err(
303 <__A::Error as _serde::de::Error>::duplicate_field(
304 "keyboardKey",
305 ),
306 );
307 }
308 m_keyboardKey = _serde::__private::Some(
309 match __A::next_value::<KeyboardKey>(&mut __map) {
310 _serde::__private::Ok(__val) => __val,
311 _serde::__private::Err(__err) => {
312 return _serde::__private::Err(__err);
313 }
314 },
315 );
316 }
317 __Field::m_bulletRadius => {
318 #[cfg(
319 any(feature = "strict", feature = "ignore_duplicates")
320 )]
321 if _serde::__private::Option::is_some(&m_bulletRadius) {
322 #[cfg(feature = "ignore_duplicates")]
323 {
324 __A::skip_value(&mut __map)?;
325 continue;
326 }
327 #[cfg(feature = "strict")]
328 return _serde::__private::Err(
329 <__A::Error as _serde::de::Error>::duplicate_field(
330 "bulletRadius",
331 ),
332 );
333 }
334 m_bulletRadius = _serde::__private::Some(
335 match __A::next_value::<f32>(&mut __map) {
336 _serde::__private::Ok(__val) => __val,
337 _serde::__private::Err(__err) => {
338 return _serde::__private::Err(__err);
339 }
340 },
341 );
342 }
343 __Field::m_bulletVelocity => {
344 #[cfg(
345 any(feature = "strict", feature = "ignore_duplicates")
346 )]
347 if _serde::__private::Option::is_some(&m_bulletVelocity) {
348 #[cfg(feature = "ignore_duplicates")]
349 {
350 __A::skip_value(&mut __map)?;
351 continue;
352 }
353 #[cfg(feature = "strict")]
354 return _serde::__private::Err(
355 <__A::Error as _serde::de::Error>::duplicate_field(
356 "bulletVelocity",
357 ),
358 );
359 }
360 m_bulletVelocity = _serde::__private::Some(
361 match __A::next_value::<f32>(&mut __map) {
362 _serde::__private::Ok(__val) => __val,
363 _serde::__private::Err(__err) => {
364 return _serde::__private::Err(__err);
365 }
366 },
367 );
368 }
369 __Field::m_bulletMass => {
370 #[cfg(
371 any(feature = "strict", feature = "ignore_duplicates")
372 )]
373 if _serde::__private::Option::is_some(&m_bulletMass) {
374 #[cfg(feature = "ignore_duplicates")]
375 {
376 __A::skip_value(&mut __map)?;
377 continue;
378 }
379 #[cfg(feature = "strict")]
380 return _serde::__private::Err(
381 <__A::Error as _serde::de::Error>::duplicate_field(
382 "bulletMass",
383 ),
384 );
385 }
386 m_bulletMass = _serde::__private::Some(
387 match __A::next_value::<f32>(&mut __map) {
388 _serde::__private::Ok(__val) => __val,
389 _serde::__private::Err(__err) => {
390 return _serde::__private::Err(__err);
391 }
392 },
393 );
394 }
395 __Field::m_damageMultiplier => {
396 #[cfg(
397 any(feature = "strict", feature = "ignore_duplicates")
398 )]
399 if _serde::__private::Option::is_some(&m_damageMultiplier) {
400 #[cfg(feature = "ignore_duplicates")]
401 {
402 __A::skip_value(&mut __map)?;
403 continue;
404 }
405 #[cfg(feature = "strict")]
406 return _serde::__private::Err(
407 <__A::Error as _serde::de::Error>::duplicate_field(
408 "damageMultiplier",
409 ),
410 );
411 }
412 m_damageMultiplier = _serde::__private::Some(
413 match __A::next_value::<f32>(&mut __map) {
414 _serde::__private::Ok(__val) => __val,
415 _serde::__private::Err(__err) => {
416 return _serde::__private::Err(__err);
417 }
418 },
419 );
420 }
421 __Field::m_maxBulletsInWorld => {
422 #[cfg(
423 any(feature = "strict", feature = "ignore_duplicates")
424 )]
425 if _serde::__private::Option::is_some(
426 &m_maxBulletsInWorld,
427 ) {
428 #[cfg(feature = "ignore_duplicates")]
429 {
430 __A::skip_value(&mut __map)?;
431 continue;
432 }
433 #[cfg(feature = "strict")]
434 return _serde::__private::Err(
435 <__A::Error as _serde::de::Error>::duplicate_field(
436 "maxBulletsInWorld",
437 ),
438 );
439 }
440 m_maxBulletsInWorld = _serde::__private::Some(
441 match __A::next_value::<i32>(&mut __map) {
442 _serde::__private::Ok(__val) => __val,
443 _serde::__private::Err(__err) => {
444 return _serde::__private::Err(__err);
445 }
446 },
447 );
448 }
449 __Field::m_bulletOffsetFromCenter => {
450 #[cfg(
451 any(feature = "strict", feature = "ignore_duplicates")
452 )]
453 if _serde::__private::Option::is_some(
454 &m_bulletOffsetFromCenter,
455 ) {
456 #[cfg(feature = "ignore_duplicates")]
457 {
458 __A::skip_value(&mut __map)?;
459 continue;
460 }
461 #[cfg(feature = "strict")]
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::duplicate_field(
464 "bulletOffsetFromCenter",
465 ),
466 );
467 }
468 m_bulletOffsetFromCenter = _serde::__private::Some(
469 match __A::next_value::<Vector4>(&mut __map) {
470 _serde::__private::Ok(__val) => __val,
471 _serde::__private::Err(__err) => {
472 return _serde::__private::Err(__err);
473 }
474 },
475 );
476 }
477 __Field::m_position => {
478 #[cfg(
479 any(feature = "strict", feature = "ignore_duplicates")
480 )]
481 if _serde::__private::Option::is_some(&m_position) {
482 #[cfg(feature = "ignore_duplicates")]
483 {
484 __A::skip_value(&mut __map)?;
485 continue;
486 }
487 #[cfg(feature = "strict")]
488 return _serde::__private::Err(
489 <__A::Error as _serde::de::Error>::duplicate_field(
490 "position",
491 ),
492 );
493 }
494 m_position = _serde::__private::Some(
495 match __A::next_value::<Vector4>(&mut __map) {
496 _serde::__private::Ok(__val) => __val,
497 _serde::__private::Err(__err) => {
498 return _serde::__private::Err(__err);
499 }
500 },
501 );
502 }
503 _ => __A::skip_value(&mut __map)?,
504 }
505 }
506 let m_name = match m_name {
507 _serde::__private::Some(__field) => __field,
508 _serde::__private::None => {
509 #[cfg(feature = "strict")]
510 return _serde::__private::Err(
511 <__A::Error as _serde::de::Error>::missing_field("name"),
512 );
513 #[cfg(not(feature = "strict"))] Default::default()
514 }
515 };
516 let m_keyboardKey = match m_keyboardKey {
517 _serde::__private::Some(__field) => __field,
518 _serde::__private::None => {
519 #[cfg(feature = "strict")]
520 return _serde::__private::Err(
521 <__A::Error as _serde::de::Error>::missing_field(
522 "keyboardKey",
523 ),
524 );
525 #[cfg(not(feature = "strict"))] Default::default()
526 }
527 };
528 let m_bulletRadius = match m_bulletRadius {
529 _serde::__private::Some(__field) => __field,
530 _serde::__private::None => {
531 #[cfg(feature = "strict")]
532 return _serde::__private::Err(
533 <__A::Error as _serde::de::Error>::missing_field(
534 "bulletRadius",
535 ),
536 );
537 #[cfg(not(feature = "strict"))] Default::default()
538 }
539 };
540 let m_bulletVelocity = match m_bulletVelocity {
541 _serde::__private::Some(__field) => __field,
542 _serde::__private::None => {
543 #[cfg(feature = "strict")]
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::missing_field(
546 "bulletVelocity",
547 ),
548 );
549 #[cfg(not(feature = "strict"))] Default::default()
550 }
551 };
552 let m_bulletMass = match m_bulletMass {
553 _serde::__private::Some(__field) => __field,
554 _serde::__private::None => {
555 #[cfg(feature = "strict")]
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::missing_field(
558 "bulletMass",
559 ),
560 );
561 #[cfg(not(feature = "strict"))] Default::default()
562 }
563 };
564 let m_damageMultiplier = match m_damageMultiplier {
565 _serde::__private::Some(__field) => __field,
566 _serde::__private::None => {
567 #[cfg(feature = "strict")]
568 return _serde::__private::Err(
569 <__A::Error as _serde::de::Error>::missing_field(
570 "damageMultiplier",
571 ),
572 );
573 #[cfg(not(feature = "strict"))] Default::default()
574 }
575 };
576 let m_maxBulletsInWorld = match m_maxBulletsInWorld {
577 _serde::__private::Some(__field) => __field,
578 _serde::__private::None => {
579 #[cfg(feature = "strict")]
580 return _serde::__private::Err(
581 <__A::Error as _serde::de::Error>::missing_field(
582 "maxBulletsInWorld",
583 ),
584 );
585 #[cfg(not(feature = "strict"))] Default::default()
586 }
587 };
588 let m_bulletOffsetFromCenter = match m_bulletOffsetFromCenter {
589 _serde::__private::Some(__field) => __field,
590 _serde::__private::None => {
591 #[cfg(feature = "strict")]
592 return _serde::__private::Err(
593 <__A::Error as _serde::de::Error>::missing_field(
594 "bulletOffsetFromCenter",
595 ),
596 );
597 #[cfg(not(feature = "strict"))] Default::default()
598 }
599 };
600 let m_position = match m_position {
601 _serde::__private::Some(__field) => __field,
602 _serde::__private::None => {
603 #[cfg(feature = "strict")]
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::missing_field("position"),
606 );
607 #[cfg(not(feature = "strict"))] Default::default()
608 }
609 };
610 let __ptr = None;
611 let parent = hkBaseObject { __ptr };
612 let parent = hkReferencedObject {
613 __ptr,
614 parent,
615 ..Default::default()
616 };
617 let parent = hkpFirstPersonGun {
618 __ptr,
619 parent,
620 m_name,
621 m_keyboardKey,
622 ..Default::default()
623 };
624 let parent = hkpBallGun {
625 __ptr,
626 parent,
627 m_bulletRadius,
628 m_bulletVelocity,
629 m_bulletMass,
630 m_damageMultiplier,
631 m_maxBulletsInWorld,
632 m_bulletOffsetFromCenter,
633 ..Default::default()
634 };
635 let __ptr = __A::class_ptr(&mut __map);
636 _serde::__private::Ok(hkpMountedBallGun {
637 __ptr,
638 parent,
639 m_position,
640 })
641 }
642 }
643 const FIELDS: &[&str] = &["position"];
644 _serde::Deserializer::deserialize_struct(
645 deserializer,
646 "hkpMountedBallGun",
647 FIELDS,
648 __hkpMountedBallGunVisitor {
649 marker: _serde::__private::PhantomData::<hkpMountedBallGun>,
650 lifetime: _serde::__private::PhantomData,
651 },
652 )
653 }
654 }
655};