havok_classes/generated/
hkaBoneAttachment_.rs

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

havok_classes/generated/
hkaBoneAttachment_.rs
