havok_classes/generated/
hkpVehicleLinearCastWheelCollideWheelState_.rs

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

havok_classes/generated/
hkpVehicleLinearCastWheelCollideWheelState_.rs
