havok_classes/generated/
hkpPhysicsSystem_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpPhysicsSystem`
5/// - version: `0`
6/// - signature: `0xff724c17`
7/// - size: ` 68`(x86)/`104`(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 hkpPhysicsSystem<'a> {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `rigidBodies`(ctype: `hkArray<hkpRigidBody*>`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "rigidBodies"))]
35    #[cfg_attr(feature = "serde", serde(rename = "rigidBodies"))]
36    pub m_rigidBodies: Vec<Pointer>,
37    /// # C++ Info
38    /// - name: `constraints`(ctype: `hkArray<hkpConstraintInstance*>`)
39    /// - offset: ` 20`(x86)/` 32`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "constraints"))]
42    #[cfg_attr(feature = "serde", serde(rename = "constraints"))]
43    pub m_constraints: Vec<Pointer>,
44    /// # C++ Info
45    /// - name: `actions`(ctype: `hkArray<hkpAction*>`)
46    /// - offset: ` 32`(x86)/` 48`(x86_64)
47    /// - type_size: ` 12`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "actions"))]
49    #[cfg_attr(feature = "serde", serde(rename = "actions"))]
50    pub m_actions: Vec<Pointer>,
51    /// # C++ Info
52    /// - name: `phantoms`(ctype: `hkArray<hkpPhantom*>`)
53    /// - offset: ` 44`(x86)/` 64`(x86_64)
54    /// - type_size: ` 12`(x86)/` 16`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "phantoms"))]
56    #[cfg_attr(feature = "serde", serde(rename = "phantoms"))]
57    pub m_phantoms: Vec<Pointer>,
58    /// # C++ Info
59    /// - name: `name`(ctype: `hkStringPtr`)
60    /// - offset: ` 56`(x86)/` 80`(x86_64)
61    /// - type_size: `  4`(x86)/`  8`(x86_64)
62    #[cfg_attr(feature = "serde", serde(borrow))]
63    #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
64    #[cfg_attr(feature = "serde", serde(rename = "name"))]
65    pub m_name: StringPtr<'a>,
66    /// # C++ Info
67    /// - name: `userData`(ctype: `hkUlong`)
68    /// - offset: ` 60`(x86)/` 88`(x86_64)
69    /// - type_size: `  4`(x86)/`  8`(x86_64)
70    #[cfg_attr(feature = "json_schema", schemars(rename = "userData"))]
71    #[cfg_attr(feature = "serde", serde(rename = "userData"))]
72    pub m_userData: Ulong,
73    /// # C++ Info
74    /// - name: `active`(ctype: `hkBool`)
75    /// - offset: ` 64`(x86)/` 96`(x86_64)
76    /// - type_size: `  1`(x86)/`  1`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "active"))]
78    #[cfg_attr(feature = "serde", serde(rename = "active"))]
79    pub m_active: bool,
80}
81const _: () = {
82    use havok_serde as _serde;
83    impl<'a> _serde::HavokClass for hkpPhysicsSystem<'a> {
84        #[inline]
85        fn name(&self) -> &'static str {
86            "hkpPhysicsSystem"
87        }
88        #[inline]
89        fn signature(&self) -> _serde::__private::Signature {
90            _serde::__private::Signature::new(0xff724c17)
91        }
92        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
93        fn deps_indexes(&self) -> Vec<usize> {
94            let mut v = Vec::new();
95            v.extend(self.m_rigidBodies.iter().map(|ptr| ptr.get()));
96            v.extend(self.m_constraints.iter().map(|ptr| ptr.get()));
97            v.extend(self.m_actions.iter().map(|ptr| ptr.get()));
98            v.extend(self.m_phantoms.iter().map(|ptr| ptr.get()));
99            v
100        }
101    }
102    impl<'a> _serde::Serialize for hkpPhysicsSystem<'a> {
103        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
104        where
105            S: _serde::ser::Serializer,
106        {
107            let class_meta = self
108                .__ptr
109                .map(|name| (name, _serde::__private::Signature::new(0xff724c17)));
110            let mut serializer = __serializer
111                .serialize_struct("hkpPhysicsSystem", class_meta, (68u64, 104u64))?;
112            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
113            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
114            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
115            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
116            serializer
117                .serialize_array_field(
118                    "rigidBodies",
119                    &self.m_rigidBodies,
120                    TypeSize::NonPtr,
121                )?;
122            serializer
123                .serialize_array_field(
124                    "constraints",
125                    &self.m_constraints,
126                    TypeSize::NonPtr,
127                )?;
128            serializer
129                .serialize_array_field("actions", &self.m_actions, TypeSize::NonPtr)?;
130            serializer
131                .serialize_array_field("phantoms", &self.m_phantoms, TypeSize::NonPtr)?;
132            serializer.serialize_field("name", &self.m_name)?;
133            serializer.serialize_field("userData", &self.m_userData)?;
134            serializer.serialize_field("active", &self.m_active)?;
135            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
136            serializer.end()
137        }
138    }
139};
140#[doc(hidden)]
141#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
142const _: () = {
143    use havok_serde as _serde;
144    #[automatically_derived]
145    impl<'de> _serde::Deserialize<'de> for hkpPhysicsSystem<'de> {
146        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
147        where
148            __D: _serde::Deserializer<'de>,
149        {
150            #[allow(non_camel_case_types)]
151            enum __Field {
152                m_rigidBodies,
153                m_constraints,
154                m_actions,
155                m_phantoms,
156                m_name,
157                m_userData,
158                m_active,
159                __ignore,
160            }
161            struct __FieldVisitor;
162            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
163                type Value = __Field;
164                fn expecting(
165                    &self,
166                    __formatter: &mut core::fmt::Formatter,
167                ) -> core::fmt::Result {
168                    core::fmt::Formatter::write_str(__formatter, "field identifier")
169                }
170                /// Intended for use in XML.
171                #[allow(clippy::match_single_binding)]
172                #[allow(clippy::reversed_empty_ranges)]
173                #[allow(clippy::single_match)]
174                fn visit_key<__E>(
175                    self,
176                    __value: &str,
177                ) -> core::result::Result<Self::Value, __E>
178                where
179                    __E: _serde::de::Error,
180                {
181                    match __value {
182                        "rigidBodies" => Ok(__Field::m_rigidBodies),
183                        "constraints" => Ok(__Field::m_constraints),
184                        "actions" => Ok(__Field::m_actions),
185                        "phantoms" => Ok(__Field::m_phantoms),
186                        "name" => Ok(__Field::m_name),
187                        "userData" => Ok(__Field::m_userData),
188                        "active" => Ok(__Field::m_active),
189                        _ => Ok(__Field::__ignore),
190                    }
191                }
192            }
193            impl<'de> _serde::Deserialize<'de> for __Field {
194                #[inline]
195                fn deserialize<__D>(
196                    __deserializer: __D,
197                ) -> core::result::Result<Self, __D::Error>
198                where
199                    __D: _serde::Deserializer<'de>,
200                {
201                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
202                }
203            }
204            struct __hkpPhysicsSystemVisitor<'de> {
205                marker: _serde::__private::PhantomData<hkpPhysicsSystem<'de>>,
206                lifetime: _serde::__private::PhantomData<&'de ()>,
207            }
208            #[allow(clippy::match_single_binding)]
209            #[allow(clippy::reversed_empty_ranges)]
210            #[allow(clippy::single_match)]
211            impl<'de> _serde::de::Visitor<'de> for __hkpPhysicsSystemVisitor<'de> {
212                type Value = hkpPhysicsSystem<'de>;
213                fn expecting(
214                    &self,
215                    __formatter: &mut core::fmt::Formatter,
216                ) -> core::fmt::Result {
217                    core::fmt::Formatter::write_str(
218                        __formatter,
219                        "struct hkpPhysicsSystem",
220                    )
221                }
222                fn visit_struct_for_bytes<__A>(
223                    self,
224                    mut __map: __A,
225                ) -> _serde::__private::Result<Self::Value, __A::Error>
226                where
227                    __A: _serde::de::MapAccess<'de>,
228                {
229                    let __ptr = __A::class_ptr(&mut __map);
230                    let parent = __A::parent_value(&mut __map)?;
231                    let mut m_rigidBodies: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
232                    let mut m_constraints: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
233                    let mut m_actions: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
234                    let mut m_phantoms: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
235                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
236                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
237                    let mut m_active: _serde::__private::Option<bool> = _serde::__private::None;
238                    for i in 0..7usize {
239                        match i {
240                            0usize => {
241                                if _serde::__private::Option::is_some(&m_rigidBodies) {
242                                    return _serde::__private::Err(
243                                        <__A::Error as _serde::de::Error>::duplicate_field(
244                                            "rigidBodies",
245                                        ),
246                                    );
247                                }
248                                m_rigidBodies = _serde::__private::Some(
249                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
250                                        _serde::__private::Ok(__val) => __val,
251                                        _serde::__private::Err(__err) => {
252                                            return _serde::__private::Err(__err);
253                                        }
254                                    },
255                                );
256                            }
257                            1usize => {
258                                if _serde::__private::Option::is_some(&m_constraints) {
259                                    return _serde::__private::Err(
260                                        <__A::Error as _serde::de::Error>::duplicate_field(
261                                            "constraints",
262                                        ),
263                                    );
264                                }
265                                m_constraints = _serde::__private::Some(
266                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
267                                        _serde::__private::Ok(__val) => __val,
268                                        _serde::__private::Err(__err) => {
269                                            return _serde::__private::Err(__err);
270                                        }
271                                    },
272                                );
273                            }
274                            2usize => {
275                                if _serde::__private::Option::is_some(&m_actions) {
276                                    return _serde::__private::Err(
277                                        <__A::Error as _serde::de::Error>::duplicate_field(
278                                            "actions",
279                                        ),
280                                    );
281                                }
282                                m_actions = _serde::__private::Some(
283                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
284                                        _serde::__private::Ok(__val) => __val,
285                                        _serde::__private::Err(__err) => {
286                                            return _serde::__private::Err(__err);
287                                        }
288                                    },
289                                );
290                            }
291                            3usize => {
292                                if _serde::__private::Option::is_some(&m_phantoms) {
293                                    return _serde::__private::Err(
294                                        <__A::Error as _serde::de::Error>::duplicate_field(
295                                            "phantoms",
296                                        ),
297                                    );
298                                }
299                                m_phantoms = _serde::__private::Some(
300                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
301                                        _serde::__private::Ok(__val) => __val,
302                                        _serde::__private::Err(__err) => {
303                                            return _serde::__private::Err(__err);
304                                        }
305                                    },
306                                );
307                            }
308                            4usize => {
309                                if _serde::__private::Option::is_some(&m_name) {
310                                    return _serde::__private::Err(
311                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
312                                    );
313                                }
314                                m_name = _serde::__private::Some(
315                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
316                                        _serde::__private::Ok(__val) => __val,
317                                        _serde::__private::Err(__err) => {
318                                            return _serde::__private::Err(__err);
319                                        }
320                                    },
321                                );
322                            }
323                            5usize => {
324                                if _serde::__private::Option::is_some(&m_userData) {
325                                    return _serde::__private::Err(
326                                        <__A::Error as _serde::de::Error>::duplicate_field(
327                                            "userData",
328                                        ),
329                                    );
330                                }
331                                m_userData = _serde::__private::Some(
332                                    match __A::next_value::<Ulong>(&mut __map) {
333                                        _serde::__private::Ok(__val) => __val,
334                                        _serde::__private::Err(__err) => {
335                                            return _serde::__private::Err(__err);
336                                        }
337                                    },
338                                );
339                            }
340                            6usize => {
341                                if _serde::__private::Option::is_some(&m_active) {
342                                    return _serde::__private::Err(
343                                        <__A::Error as _serde::de::Error>::duplicate_field("active"),
344                                    );
345                                }
346                                m_active = _serde::__private::Some(
347                                    match __A::next_value::<bool>(&mut __map) {
348                                        _serde::__private::Ok(__val) => __val,
349                                        _serde::__private::Err(__err) => {
350                                            return _serde::__private::Err(__err);
351                                        }
352                                    },
353                                );
354                            }
355                            _ => {}
356                        }
357                    }
358                    __A::pad(&mut __map, 3usize, 7usize)?;
359                    let m_rigidBodies = match m_rigidBodies {
360                        _serde::__private::Some(__field) => __field,
361                        _serde::__private::None => {
362                            return _serde::__private::Err(
363                                <__A::Error as _serde::de::Error>::missing_field(
364                                    "rigidBodies",
365                                ),
366                            );
367                        }
368                    };
369                    let m_constraints = match m_constraints {
370                        _serde::__private::Some(__field) => __field,
371                        _serde::__private::None => {
372                            return _serde::__private::Err(
373                                <__A::Error as _serde::de::Error>::missing_field(
374                                    "constraints",
375                                ),
376                            );
377                        }
378                    };
379                    let m_actions = match m_actions {
380                        _serde::__private::Some(__field) => __field,
381                        _serde::__private::None => {
382                            return _serde::__private::Err(
383                                <__A::Error as _serde::de::Error>::missing_field("actions"),
384                            );
385                        }
386                    };
387                    let m_phantoms = match m_phantoms {
388                        _serde::__private::Some(__field) => __field,
389                        _serde::__private::None => {
390                            return _serde::__private::Err(
391                                <__A::Error as _serde::de::Error>::missing_field("phantoms"),
392                            );
393                        }
394                    };
395                    let m_name = match m_name {
396                        _serde::__private::Some(__field) => __field,
397                        _serde::__private::None => {
398                            return _serde::__private::Err(
399                                <__A::Error as _serde::de::Error>::missing_field("name"),
400                            );
401                        }
402                    };
403                    let m_userData = match m_userData {
404                        _serde::__private::Some(__field) => __field,
405                        _serde::__private::None => {
406                            return _serde::__private::Err(
407                                <__A::Error as _serde::de::Error>::missing_field("userData"),
408                            );
409                        }
410                    };
411                    let m_active = match m_active {
412                        _serde::__private::Some(__field) => __field,
413                        _serde::__private::None => {
414                            return _serde::__private::Err(
415                                <__A::Error as _serde::de::Error>::missing_field("active"),
416                            );
417                        }
418                    };
419                    _serde::__private::Ok(hkpPhysicsSystem {
420                        __ptr,
421                        parent,
422                        m_rigidBodies,
423                        m_constraints,
424                        m_actions,
425                        m_phantoms,
426                        m_name,
427                        m_userData,
428                        m_active,
429                    })
430                }
431                #[allow(clippy::manual_unwrap_or_default)]
432                fn visit_struct<__A>(
433                    self,
434                    mut __map: __A,
435                ) -> _serde::__private::Result<Self::Value, __A::Error>
436                where
437                    __A: _serde::de::MapAccess<'de>,
438                {
439                    let mut m_rigidBodies: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
440                    let mut m_constraints: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
441                    let mut m_actions: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
442                    let mut m_phantoms: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
443                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
444                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
445                    let mut m_active: _serde::__private::Option<bool> = _serde::__private::None;
446                    while let _serde::__private::Some(__key) = {
447                        __A::next_key::<__Field>(&mut __map)?
448                    } {
449                        match __key {
450                            __Field::m_rigidBodies => {
451                                #[cfg(
452                                    any(feature = "strict", feature = "ignore_duplicates")
453                                )]
454                                if _serde::__private::Option::is_some(&m_rigidBodies) {
455                                    #[cfg(feature = "ignore_duplicates")]
456                                    {
457                                        __A::skip_value(&mut __map)?;
458                                        continue;
459                                    }
460                                    #[cfg(feature = "strict")]
461                                    return _serde::__private::Err(
462                                        <__A::Error as _serde::de::Error>::duplicate_field(
463                                            "rigidBodies",
464                                        ),
465                                    );
466                                }
467                                m_rigidBodies = _serde::__private::Some(
468                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
469                                        _serde::__private::Ok(__val) => __val,
470                                        _serde::__private::Err(__err) => {
471                                            return _serde::__private::Err(__err);
472                                        }
473                                    },
474                                );
475                            }
476                            __Field::m_constraints => {
477                                #[cfg(
478                                    any(feature = "strict", feature = "ignore_duplicates")
479                                )]
480                                if _serde::__private::Option::is_some(&m_constraints) {
481                                    #[cfg(feature = "ignore_duplicates")]
482                                    {
483                                        __A::skip_value(&mut __map)?;
484                                        continue;
485                                    }
486                                    #[cfg(feature = "strict")]
487                                    return _serde::__private::Err(
488                                        <__A::Error as _serde::de::Error>::duplicate_field(
489                                            "constraints",
490                                        ),
491                                    );
492                                }
493                                m_constraints = _serde::__private::Some(
494                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
495                                        _serde::__private::Ok(__val) => __val,
496                                        _serde::__private::Err(__err) => {
497                                            return _serde::__private::Err(__err);
498                                        }
499                                    },
500                                );
501                            }
502                            __Field::m_actions => {
503                                #[cfg(
504                                    any(feature = "strict", feature = "ignore_duplicates")
505                                )]
506                                if _serde::__private::Option::is_some(&m_actions) {
507                                    #[cfg(feature = "ignore_duplicates")]
508                                    {
509                                        __A::skip_value(&mut __map)?;
510                                        continue;
511                                    }
512                                    #[cfg(feature = "strict")]
513                                    return _serde::__private::Err(
514                                        <__A::Error as _serde::de::Error>::duplicate_field(
515                                            "actions",
516                                        ),
517                                    );
518                                }
519                                m_actions = _serde::__private::Some(
520                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
521                                        _serde::__private::Ok(__val) => __val,
522                                        _serde::__private::Err(__err) => {
523                                            return _serde::__private::Err(__err);
524                                        }
525                                    },
526                                );
527                            }
528                            __Field::m_phantoms => {
529                                #[cfg(
530                                    any(feature = "strict", feature = "ignore_duplicates")
531                                )]
532                                if _serde::__private::Option::is_some(&m_phantoms) {
533                                    #[cfg(feature = "ignore_duplicates")]
534                                    {
535                                        __A::skip_value(&mut __map)?;
536                                        continue;
537                                    }
538                                    #[cfg(feature = "strict")]
539                                    return _serde::__private::Err(
540                                        <__A::Error as _serde::de::Error>::duplicate_field(
541                                            "phantoms",
542                                        ),
543                                    );
544                                }
545                                m_phantoms = _serde::__private::Some(
546                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
547                                        _serde::__private::Ok(__val) => __val,
548                                        _serde::__private::Err(__err) => {
549                                            return _serde::__private::Err(__err);
550                                        }
551                                    },
552                                );
553                            }
554                            __Field::m_name => {
555                                #[cfg(
556                                    any(feature = "strict", feature = "ignore_duplicates")
557                                )]
558                                if _serde::__private::Option::is_some(&m_name) {
559                                    #[cfg(feature = "ignore_duplicates")]
560                                    {
561                                        __A::skip_value(&mut __map)?;
562                                        continue;
563                                    }
564                                    #[cfg(feature = "strict")]
565                                    return _serde::__private::Err(
566                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
567                                    );
568                                }
569                                m_name = _serde::__private::Some(
570                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
571                                        _serde::__private::Ok(__val) => __val,
572                                        _serde::__private::Err(__err) => {
573                                            return _serde::__private::Err(__err);
574                                        }
575                                    },
576                                );
577                            }
578                            __Field::m_userData => {
579                                #[cfg(
580                                    any(feature = "strict", feature = "ignore_duplicates")
581                                )]
582                                if _serde::__private::Option::is_some(&m_userData) {
583                                    #[cfg(feature = "ignore_duplicates")]
584                                    {
585                                        __A::skip_value(&mut __map)?;
586                                        continue;
587                                    }
588                                    #[cfg(feature = "strict")]
589                                    return _serde::__private::Err(
590                                        <__A::Error as _serde::de::Error>::duplicate_field(
591                                            "userData",
592                                        ),
593                                    );
594                                }
595                                m_userData = _serde::__private::Some(
596                                    match __A::next_value::<Ulong>(&mut __map) {
597                                        _serde::__private::Ok(__val) => __val,
598                                        _serde::__private::Err(__err) => {
599                                            return _serde::__private::Err(__err);
600                                        }
601                                    },
602                                );
603                            }
604                            __Field::m_active => {
605                                #[cfg(
606                                    any(feature = "strict", feature = "ignore_duplicates")
607                                )]
608                                if _serde::__private::Option::is_some(&m_active) {
609                                    #[cfg(feature = "ignore_duplicates")]
610                                    {
611                                        __A::skip_value(&mut __map)?;
612                                        continue;
613                                    }
614                                    #[cfg(feature = "strict")]
615                                    return _serde::__private::Err(
616                                        <__A::Error as _serde::de::Error>::duplicate_field("active"),
617                                    );
618                                }
619                                m_active = _serde::__private::Some(
620                                    match __A::next_value::<bool>(&mut __map) {
621                                        _serde::__private::Ok(__val) => __val,
622                                        _serde::__private::Err(__err) => {
623                                            return _serde::__private::Err(__err);
624                                        }
625                                    },
626                                );
627                            }
628                            _ => __A::skip_value(&mut __map)?,
629                        }
630                    }
631                    let m_rigidBodies = match m_rigidBodies {
632                        _serde::__private::Some(__field) => __field,
633                        _serde::__private::None => {
634                            #[cfg(feature = "strict")]
635                            return _serde::__private::Err(
636                                <__A::Error as _serde::de::Error>::missing_field(
637                                    "rigidBodies",
638                                ),
639                            );
640                            #[cfg(not(feature = "strict"))] Default::default()
641                        }
642                    };
643                    let m_constraints = match m_constraints {
644                        _serde::__private::Some(__field) => __field,
645                        _serde::__private::None => {
646                            #[cfg(feature = "strict")]
647                            return _serde::__private::Err(
648                                <__A::Error as _serde::de::Error>::missing_field(
649                                    "constraints",
650                                ),
651                            );
652                            #[cfg(not(feature = "strict"))] Default::default()
653                        }
654                    };
655                    let m_actions = match m_actions {
656                        _serde::__private::Some(__field) => __field,
657                        _serde::__private::None => {
658                            #[cfg(feature = "strict")]
659                            return _serde::__private::Err(
660                                <__A::Error as _serde::de::Error>::missing_field("actions"),
661                            );
662                            #[cfg(not(feature = "strict"))] Default::default()
663                        }
664                    };
665                    let m_phantoms = match m_phantoms {
666                        _serde::__private::Some(__field) => __field,
667                        _serde::__private::None => {
668                            #[cfg(feature = "strict")]
669                            return _serde::__private::Err(
670                                <__A::Error as _serde::de::Error>::missing_field("phantoms"),
671                            );
672                            #[cfg(not(feature = "strict"))] Default::default()
673                        }
674                    };
675                    let m_name = match m_name {
676                        _serde::__private::Some(__field) => __field,
677                        _serde::__private::None => {
678                            #[cfg(feature = "strict")]
679                            return _serde::__private::Err(
680                                <__A::Error as _serde::de::Error>::missing_field("name"),
681                            );
682                            #[cfg(not(feature = "strict"))] Default::default()
683                        }
684                    };
685                    let m_userData = match m_userData {
686                        _serde::__private::Some(__field) => __field,
687                        _serde::__private::None => {
688                            #[cfg(feature = "strict")]
689                            return _serde::__private::Err(
690                                <__A::Error as _serde::de::Error>::missing_field("userData"),
691                            );
692                            #[cfg(not(feature = "strict"))] Default::default()
693                        }
694                    };
695                    let m_active = match m_active {
696                        _serde::__private::Some(__field) => __field,
697                        _serde::__private::None => {
698                            #[cfg(feature = "strict")]
699                            return _serde::__private::Err(
700                                <__A::Error as _serde::de::Error>::missing_field("active"),
701                            );
702                            #[cfg(not(feature = "strict"))] Default::default()
703                        }
704                    };
705                    let __ptr = None;
706                    let parent = hkBaseObject { __ptr };
707                    let parent = hkReferencedObject {
708                        __ptr,
709                        parent,
710                        ..Default::default()
711                    };
712                    let __ptr = __A::class_ptr(&mut __map);
713                    _serde::__private::Ok(hkpPhysicsSystem {
714                        __ptr,
715                        parent,
716                        m_rigidBodies,
717                        m_constraints,
718                        m_actions,
719                        m_phantoms,
720                        m_name,
721                        m_userData,
722                        m_active,
723                    })
724                }
725            }
726            const FIELDS: &[&str] = &[
727                "rigidBodies",
728                "constraints",
729                "actions",
730                "phantoms",
731                "name",
732                "userData",
733                "active",
734            ];
735            _serde::Deserializer::deserialize_struct(
736                deserializer,
737                "hkpPhysicsSystem",
738                FIELDS,
739                __hkpPhysicsSystemVisitor {
740                    marker: _serde::__private::PhantomData::<hkpPhysicsSystem>,
741                    lifetime: _serde::__private::PhantomData,
742                },
743            )
744        }
745    }
746};
havok_classes/generated/hkpPhysicsSystem_.rs

havok_classes/generated/
hkpPhysicsSystem_.rs
