havok_classes/generated/
hkpVehicleDefaultSuspensionWheelSpringSuspensionParameters_.rs

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