havok_classes/generated/
hkpMovingSurfaceModifierConstraintAtom_.rs

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