havok_classes/generated/
hkpVehicleDefaultAerodynamics_.rs

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

havok_classes/generated/
hkpVehicleDefaultAerodynamics_.rs
