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