havok_classes/generated/
hkpGroupFilter_.rs

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