havok_classes/generated/
BSRagdollContactListenerModifier_.rs

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

havok_classes/generated/
BSRagdollContactListenerModifier_.rs
