havok_classes/generated/
hkMemoryMeshShape_.rs

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