havok_classes/generated/
hkpStorageExtendedMeshShapeShapeSubpartStorage_.rs

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

havok_classes/generated/
hkpStorageExtendedMeshShapeShapeSubpartStorage_.rs
