havok_classes/generated/
hkpCompressedMeshShapeBigTriangle_.rs

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

havok_classes/generated/
hkpCompressedMeshShapeBigTriangle_.rs
