havok_classes/generated/
hkpVehicleRayCastWheelCollide_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpVehicleRayCastWheelCollide`
5/// - version: `1`
6/// - signature: `0x41efd9e3`
7/// - size: ` 36`(x86)/` 64`(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 hkpVehicleRayCastWheelCollide {
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    pub parent: hkpVehicleWheelCollide,
30    /// # C++ Info
31    /// - name: `wheelCollisionFilterInfo`(ctype: `hkUint32`)
32    /// - offset: ` 12`(x86)/` 24`(x86_64)
33    /// - type_size: `  4`(x86)/`  4`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "wheelCollisionFilterInfo"))]
35    #[cfg_attr(feature = "serde", serde(rename = "wheelCollisionFilterInfo"))]
36    pub m_wheelCollisionFilterInfo: u32,
37    /// # C++ Info
38    /// - name: `phantom`(ctype: `struct hkpAabbPhantom*`)
39    /// - offset: ` 16`(x86)/` 32`(x86_64)
40    /// - type_size: `  4`(x86)/`  8`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "phantom"))]
42    #[cfg_attr(feature = "serde", serde(rename = "phantom"))]
43    pub m_phantom: Pointer,
44    /// # C++ Info
45    /// - name: `rejectRayChassisListener`(ctype: `struct hkpRejectChassisListener`)
46    /// - offset: ` 20`(x86)/` 40`(x86_64)
47    /// - type_size: ` 16`(x86)/` 24`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "rejectRayChassisListener"))]
49    #[cfg_attr(feature = "serde", serde(rename = "rejectRayChassisListener"))]
50    pub m_rejectRayChassisListener: hkpRejectChassisListener,
51}
52const _: () = {
53    use havok_serde as _serde;
54    impl _serde::HavokClass for hkpVehicleRayCastWheelCollide {
55        #[inline]
56        fn name(&self) -> &'static str {
57            "hkpVehicleRayCastWheelCollide"
58        }
59        #[inline]
60        fn signature(&self) -> _serde::__private::Signature {
61            _serde::__private::Signature::new(0x41efd9e3)
62        }
63        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
64        fn deps_indexes(&self) -> Vec<usize> {
65            let mut v = Vec::new();
66            v.push(self.m_phantom.get());
67            v.extend(self.m_rejectRayChassisListener.deps_indexes());
68            v
69        }
70    }
71    impl _serde::Serialize for hkpVehicleRayCastWheelCollide {
72        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
73        where
74            S: _serde::ser::Serializer,
75        {
76            let class_meta = self
77                .__ptr
78                .map(|name| (name, _serde::__private::Signature::new(0x41efd9e3)));
79            let mut serializer = __serializer
80                .serialize_struct(
81                    "hkpVehicleRayCastWheelCollide",
82                    class_meta,
83                    (36u64, 64u64),
84                )?;
85            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
86            serializer
87                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
88            serializer
89                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
90            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
91            serializer.serialize_field("alreadyUsed", &self.parent.m_alreadyUsed)?;
92            serializer.skip_field("type", &self.parent.m_type)?;
93            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
94            serializer
95                .serialize_field(
96                    "wheelCollisionFilterInfo",
97                    &self.m_wheelCollisionFilterInfo,
98                )?;
99            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
100            serializer.serialize_field("phantom", &self.m_phantom)?;
101            serializer
102                .serialize_field(
103                    "rejectRayChassisListener",
104                    &self.m_rejectRayChassisListener,
105                )?;
106            serializer.end()
107        }
108    }
109};
110#[doc(hidden)]
111#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
112const _: () = {
113    use havok_serde as _serde;
114    #[automatically_derived]
115    impl<'de> _serde::Deserialize<'de> for hkpVehicleRayCastWheelCollide {
116        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
117        where
118            __D: _serde::Deserializer<'de>,
119        {
120            #[allow(non_camel_case_types)]
121            enum __Field {
122                m_alreadyUsed,
123                m_wheelCollisionFilterInfo,
124                m_phantom,
125                m_rejectRayChassisListener,
126                __ignore,
127            }
128            struct __FieldVisitor;
129            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
130                type Value = __Field;
131                fn expecting(
132                    &self,
133                    __formatter: &mut core::fmt::Formatter,
134                ) -> core::fmt::Result {
135                    core::fmt::Formatter::write_str(__formatter, "field identifier")
136                }
137                /// Intended for use in XML.
138                #[allow(clippy::match_single_binding)]
139                #[allow(clippy::reversed_empty_ranges)]
140                #[allow(clippy::single_match)]
141                fn visit_key<__E>(
142                    self,
143                    __value: &str,
144                ) -> core::result::Result<Self::Value, __E>
145                where
146                    __E: _serde::de::Error,
147                {
148                    match __value {
149                        "alreadyUsed" => Ok(__Field::m_alreadyUsed),
150                        "wheelCollisionFilterInfo" => {
151                            Ok(__Field::m_wheelCollisionFilterInfo)
152                        }
153                        "phantom" => Ok(__Field::m_phantom),
154                        "rejectRayChassisListener" => {
155                            Ok(__Field::m_rejectRayChassisListener)
156                        }
157                        _ => Ok(__Field::__ignore),
158                    }
159                }
160            }
161            impl<'de> _serde::Deserialize<'de> for __Field {
162                #[inline]
163                fn deserialize<__D>(
164                    __deserializer: __D,
165                ) -> core::result::Result<Self, __D::Error>
166                where
167                    __D: _serde::Deserializer<'de>,
168                {
169                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
170                }
171            }
172            struct __hkpVehicleRayCastWheelCollideVisitor<'de> {
173                marker: _serde::__private::PhantomData<hkpVehicleRayCastWheelCollide>,
174                lifetime: _serde::__private::PhantomData<&'de ()>,
175            }
176            #[allow(clippy::match_single_binding)]
177            #[allow(clippy::reversed_empty_ranges)]
178            #[allow(clippy::single_match)]
179            impl<'de> _serde::de::Visitor<'de>
180            for __hkpVehicleRayCastWheelCollideVisitor<'de> {
181                type Value = hkpVehicleRayCastWheelCollide;
182                fn expecting(
183                    &self,
184                    __formatter: &mut core::fmt::Formatter,
185                ) -> core::fmt::Result {
186                    core::fmt::Formatter::write_str(
187                        __formatter,
188                        "struct hkpVehicleRayCastWheelCollide",
189                    )
190                }
191                fn visit_struct_for_bytes<__A>(
192                    self,
193                    mut __map: __A,
194                ) -> _serde::__private::Result<Self::Value, __A::Error>
195                where
196                    __A: _serde::de::MapAccess<'de>,
197                {
198                    let __ptr = __A::class_ptr(&mut __map);
199                    let parent = __A::parent_value(&mut __map)?;
200                    let mut m_wheelCollisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
201                    let mut m_phantom: _serde::__private::Option<Pointer> = _serde::__private::None;
202                    let mut m_rejectRayChassisListener: _serde::__private::Option<
203                        hkpRejectChassisListener,
204                    > = _serde::__private::None;
205                    for i in 0..3usize {
206                        match i {
207                            0usize => {
208                                if _serde::__private::Option::is_some(
209                                    &m_wheelCollisionFilterInfo,
210                                ) {
211                                    return _serde::__private::Err(
212                                        <__A::Error as _serde::de::Error>::duplicate_field(
213                                            "wheelCollisionFilterInfo",
214                                        ),
215                                    );
216                                }
217                                m_wheelCollisionFilterInfo = _serde::__private::Some(
218                                    match __A::next_value::<u32>(&mut __map) {
219                                        _serde::__private::Ok(__val) => __val,
220                                        _serde::__private::Err(__err) => {
221                                            return _serde::__private::Err(__err);
222                                        }
223                                    },
224                                );
225                            }
226                            1usize => {
227                                if _serde::__private::Option::is_some(&m_phantom) {
228                                    return _serde::__private::Err(
229                                        <__A::Error as _serde::de::Error>::duplicate_field(
230                                            "phantom",
231                                        ),
232                                    );
233                                }
234                                __A::pad(&mut __map, 0usize, 4usize)?;
235                                m_phantom = _serde::__private::Some(
236                                    match __A::next_value::<Pointer>(&mut __map) {
237                                        _serde::__private::Ok(__val) => __val,
238                                        _serde::__private::Err(__err) => {
239                                            return _serde::__private::Err(__err);
240                                        }
241                                    },
242                                );
243                            }
244                            2usize => {
245                                if _serde::__private::Option::is_some(
246                                    &m_rejectRayChassisListener,
247                                ) {
248                                    return _serde::__private::Err(
249                                        <__A::Error as _serde::de::Error>::duplicate_field(
250                                            "rejectRayChassisListener",
251                                        ),
252                                    );
253                                }
254                                m_rejectRayChassisListener = _serde::__private::Some(
255                                    match __A::next_value::<
256                                        hkpRejectChassisListener,
257                                    >(&mut __map) {
258                                        _serde::__private::Ok(__val) => __val,
259                                        _serde::__private::Err(__err) => {
260                                            return _serde::__private::Err(__err);
261                                        }
262                                    },
263                                );
264                            }
265                            _ => {}
266                        }
267                    }
268                    let m_wheelCollisionFilterInfo = match m_wheelCollisionFilterInfo {
269                        _serde::__private::Some(__field) => __field,
270                        _serde::__private::None => {
271                            return _serde::__private::Err(
272                                <__A::Error as _serde::de::Error>::missing_field(
273                                    "wheelCollisionFilterInfo",
274                                ),
275                            );
276                        }
277                    };
278                    let m_phantom = match m_phantom {
279                        _serde::__private::Some(__field) => __field,
280                        _serde::__private::None => {
281                            return _serde::__private::Err(
282                                <__A::Error as _serde::de::Error>::missing_field("phantom"),
283                            );
284                        }
285                    };
286                    let m_rejectRayChassisListener = match m_rejectRayChassisListener {
287                        _serde::__private::Some(__field) => __field,
288                        _serde::__private::None => {
289                            return _serde::__private::Err(
290                                <__A::Error as _serde::de::Error>::missing_field(
291                                    "rejectRayChassisListener",
292                                ),
293                            );
294                        }
295                    };
296                    _serde::__private::Ok(hkpVehicleRayCastWheelCollide {
297                        __ptr,
298                        parent,
299                        m_wheelCollisionFilterInfo,
300                        m_phantom,
301                        m_rejectRayChassisListener,
302                    })
303                }
304                #[allow(clippy::manual_unwrap_or_default)]
305                fn visit_struct<__A>(
306                    self,
307                    mut __map: __A,
308                ) -> _serde::__private::Result<Self::Value, __A::Error>
309                where
310                    __A: _serde::de::MapAccess<'de>,
311                {
312                    let mut m_alreadyUsed: _serde::__private::Option<bool> = _serde::__private::None;
313                    let mut m_wheelCollisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
314                    let mut m_phantom: _serde::__private::Option<Pointer> = _serde::__private::None;
315                    let mut m_rejectRayChassisListener: _serde::__private::Option<
316                        hkpRejectChassisListener,
317                    > = _serde::__private::None;
318                    while let _serde::__private::Some(__key) = {
319                        __A::next_key::<__Field>(&mut __map)?
320                    } {
321                        match __key {
322                            __Field::m_alreadyUsed => {
323                                #[cfg(
324                                    any(feature = "strict", feature = "ignore_duplicates")
325                                )]
326                                if _serde::__private::Option::is_some(&m_alreadyUsed) {
327                                    #[cfg(feature = "ignore_duplicates")]
328                                    {
329                                        __A::skip_value(&mut __map)?;
330                                        continue;
331                                    }
332                                    #[cfg(feature = "strict")]
333                                    return _serde::__private::Err(
334                                        <__A::Error as _serde::de::Error>::duplicate_field(
335                                            "alreadyUsed",
336                                        ),
337                                    );
338                                }
339                                m_alreadyUsed = _serde::__private::Some(
340                                    match __A::next_value::<bool>(&mut __map) {
341                                        _serde::__private::Ok(__val) => __val,
342                                        _serde::__private::Err(__err) => {
343                                            return _serde::__private::Err(__err);
344                                        }
345                                    },
346                                );
347                            }
348                            __Field::m_wheelCollisionFilterInfo => {
349                                #[cfg(
350                                    any(feature = "strict", feature = "ignore_duplicates")
351                                )]
352                                if _serde::__private::Option::is_some(
353                                    &m_wheelCollisionFilterInfo,
354                                ) {
355                                    #[cfg(feature = "ignore_duplicates")]
356                                    {
357                                        __A::skip_value(&mut __map)?;
358                                        continue;
359                                    }
360                                    #[cfg(feature = "strict")]
361                                    return _serde::__private::Err(
362                                        <__A::Error as _serde::de::Error>::duplicate_field(
363                                            "wheelCollisionFilterInfo",
364                                        ),
365                                    );
366                                }
367                                m_wheelCollisionFilterInfo = _serde::__private::Some(
368                                    match __A::next_value::<u32>(&mut __map) {
369                                        _serde::__private::Ok(__val) => __val,
370                                        _serde::__private::Err(__err) => {
371                                            return _serde::__private::Err(__err);
372                                        }
373                                    },
374                                );
375                            }
376                            __Field::m_phantom => {
377                                #[cfg(
378                                    any(feature = "strict", feature = "ignore_duplicates")
379                                )]
380                                if _serde::__private::Option::is_some(&m_phantom) {
381                                    #[cfg(feature = "ignore_duplicates")]
382                                    {
383                                        __A::skip_value(&mut __map)?;
384                                        continue;
385                                    }
386                                    #[cfg(feature = "strict")]
387                                    return _serde::__private::Err(
388                                        <__A::Error as _serde::de::Error>::duplicate_field(
389                                            "phantom",
390                                        ),
391                                    );
392                                }
393                                m_phantom = _serde::__private::Some(
394                                    match __A::next_value::<Pointer>(&mut __map) {
395                                        _serde::__private::Ok(__val) => __val,
396                                        _serde::__private::Err(__err) => {
397                                            return _serde::__private::Err(__err);
398                                        }
399                                    },
400                                );
401                            }
402                            __Field::m_rejectRayChassisListener => {
403                                #[cfg(
404                                    any(feature = "strict", feature = "ignore_duplicates")
405                                )]
406                                if _serde::__private::Option::is_some(
407                                    &m_rejectRayChassisListener,
408                                ) {
409                                    #[cfg(feature = "ignore_duplicates")]
410                                    {
411                                        __A::skip_value(&mut __map)?;
412                                        continue;
413                                    }
414                                    #[cfg(feature = "strict")]
415                                    return _serde::__private::Err(
416                                        <__A::Error as _serde::de::Error>::duplicate_field(
417                                            "rejectRayChassisListener",
418                                        ),
419                                    );
420                                }
421                                m_rejectRayChassisListener = _serde::__private::Some(
422                                    match __A::next_value::<
423                                        hkpRejectChassisListener,
424                                    >(&mut __map) {
425                                        _serde::__private::Ok(__val) => __val,
426                                        _serde::__private::Err(__err) => {
427                                            return _serde::__private::Err(__err);
428                                        }
429                                    },
430                                );
431                            }
432                            _ => __A::skip_value(&mut __map)?,
433                        }
434                    }
435                    let m_alreadyUsed = match m_alreadyUsed {
436                        _serde::__private::Some(__field) => __field,
437                        _serde::__private::None => {
438                            #[cfg(feature = "strict")]
439                            return _serde::__private::Err(
440                                <__A::Error as _serde::de::Error>::missing_field(
441                                    "alreadyUsed",
442                                ),
443                            );
444                            #[cfg(not(feature = "strict"))] Default::default()
445                        }
446                    };
447                    let m_wheelCollisionFilterInfo = match m_wheelCollisionFilterInfo {
448                        _serde::__private::Some(__field) => __field,
449                        _serde::__private::None => {
450                            #[cfg(feature = "strict")]
451                            return _serde::__private::Err(
452                                <__A::Error as _serde::de::Error>::missing_field(
453                                    "wheelCollisionFilterInfo",
454                                ),
455                            );
456                            #[cfg(not(feature = "strict"))] Default::default()
457                        }
458                    };
459                    let m_phantom = match m_phantom {
460                        _serde::__private::Some(__field) => __field,
461                        _serde::__private::None => {
462                            #[cfg(feature = "strict")]
463                            return _serde::__private::Err(
464                                <__A::Error as _serde::de::Error>::missing_field("phantom"),
465                            );
466                            #[cfg(not(feature = "strict"))] Default::default()
467                        }
468                    };
469                    let m_rejectRayChassisListener = match m_rejectRayChassisListener {
470                        _serde::__private::Some(__field) => __field,
471                        _serde::__private::None => {
472                            #[cfg(feature = "strict")]
473                            return _serde::__private::Err(
474                                <__A::Error as _serde::de::Error>::missing_field(
475                                    "rejectRayChassisListener",
476                                ),
477                            );
478                            #[cfg(not(feature = "strict"))] Default::default()
479                        }
480                    };
481                    let __ptr = None;
482                    let parent = hkBaseObject { __ptr };
483                    let parent = hkReferencedObject {
484                        __ptr,
485                        parent,
486                        ..Default::default()
487                    };
488                    let parent = hkpVehicleWheelCollide {
489                        __ptr,
490                        parent,
491                        m_alreadyUsed,
492                        ..Default::default()
493                    };
494                    let __ptr = __A::class_ptr(&mut __map);
495                    _serde::__private::Ok(hkpVehicleRayCastWheelCollide {
496                        __ptr,
497                        parent,
498                        m_wheelCollisionFilterInfo,
499                        m_phantom,
500                        m_rejectRayChassisListener,
501                    })
502                }
503            }
504            const FIELDS: &[&str] = &[
505                "wheelCollisionFilterInfo",
506                "phantom",
507                "rejectRayChassisListener",
508            ];
509            _serde::Deserializer::deserialize_struct(
510                deserializer,
511                "hkpVehicleRayCastWheelCollide",
512                FIELDS,
513                __hkpVehicleRayCastWheelCollideVisitor {
514                    marker: _serde::__private::PhantomData::<
515                        hkpVehicleRayCastWheelCollide,
516                    >,
517                    lifetime: _serde::__private::PhantomData,
518                },
519            )
520        }
521    }
522};