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