havok_classes/generated/
hkbCharacterDataCharacterControllerInfo_.rs

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