havok_classes/generated/
hkSimpleLocalFrame_.rs

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

havok_classes/generated/
hkSimpleLocalFrame_.rs
