havok_classes/generated/
hkpProjectileGun_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpProjectileGun`
5/// - version: `0`
6/// - signature: `0xb4f30148`
7/// - size: ` 64`(x86)/`104`(x86_64)
8/// -  vtable: `true`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[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    /// # C++ Info
32    /// - name: `maxProjectiles`(ctype: `hkInt32`)
33    /// - offset: ` 32`(x86)/` 56`(x86_64)
34    /// - type_size: `  4`(x86)/`  4`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "maxProjectiles"))]
36    #[cfg_attr(feature = "serde", serde(rename = "maxProjectiles"))]
37    pub m_maxProjectiles: i32,
38    /// # C++ Info
39    /// - name: `reloadTime`(ctype: `hkReal`)
40    /// - offset: ` 36`(x86)/` 60`(x86_64)
41    /// - type_size: `  4`(x86)/`  4`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "reloadTime"))]
43    #[cfg_attr(feature = "serde", serde(rename = "reloadTime"))]
44    pub m_reloadTime: f32,
45    /// # C++ Info
46    /// - name: `reload`(ctype: `hkReal`)
47    /// - offset: ` 40`(x86)/` 64`(x86_64)
48    /// - type_size: `  4`(x86)/`  4`(x86_64)
49    /// - flags: `SERIALIZE_IGNORED`
50    #[cfg_attr(feature = "json_schema", schemars(rename = "reload"))]
51    #[cfg_attr(feature = "serde", serde(rename = "reload"))]
52    pub m_reload: f32,
53    /// # C++ Info
54    /// - name: `projectiles`(ctype: `hkArray<void*>`)
55    /// - offset: ` 44`(x86)/` 72`(x86_64)
56    /// - type_size: ` 12`(x86)/` 16`(x86_64)
57    /// - flags: `SERIALIZE_IGNORED`
58    #[cfg_attr(feature = "json_schema", schemars(rename = "projectiles"))]
59    #[cfg_attr(feature = "serde", serde(rename = "projectiles"))]
60    pub m_projectiles: Vec<Pointer>,
61    /// # C++ Info
62    /// - name: `world`(ctype: `void*`)
63    /// - offset: ` 56`(x86)/` 88`(x86_64)
64    /// - type_size: `  4`(x86)/`  8`(x86_64)
65    /// - flags: `SERIALIZE_IGNORED`
66    #[cfg_attr(feature = "json_schema", schemars(rename = "world"))]
67    #[cfg_attr(feature = "serde", serde(rename = "world"))]
68    pub m_world: Pointer,
69    /// # C++ Info
70    /// - name: `destructionWorld`(ctype: `void*`)
71    /// - offset: ` 60`(x86)/` 96`(x86_64)
72    /// - type_size: `  4`(x86)/`  8`(x86_64)
73    /// - flags: `SERIALIZE_IGNORED`
74    #[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                /// Intended for use in XML.
166                #[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};
havok_classes/generated/hkpProjectileGun_.rs

havok_classes/generated/
hkpProjectileGun_.rs
