havok_classes/generated/
hkpPhysicsSystemWithContacts_.rs

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