havok_classes/generated/
hkaMeshBinding_.rs

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

havok_classes/generated/
hkaMeshBinding_.rs
