havok_classes/generated/
hkpTransformShape_.rs

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

havok_classes/generated/
hkpTransformShape_.rs
