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