havok_classes/generated/
hkpVehicleDefaultAnalogDriverInput_.rs

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