havok_classes/generated/
hkpCenterOfMassChangerModifierConstraintAtom_.rs

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