havok_classes/generated/
hkpModifierConstraintAtom_.rs

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

havok_classes/generated/
hkpModifierConstraintAtom_.rs
