havok_classes/generated/
hkbCharacter_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbCharacter`
5/// - version: `2`
6/// - signature: `0x3088a5c5`
7/// - size: ` 88`(x86)/`160`(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 hkbCharacter<'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: `nearbyCharacters`(ctype: `hkArray<hkbCharacter*>`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "nearbyCharacters"))]
35    #[cfg_attr(feature = "serde", serde(rename = "nearbyCharacters"))]
36    pub m_nearbyCharacters: Vec<Pointer>,
37    /// # C++ Info
38    /// - name: `currentLod`(ctype: `hkInt16`)
39    /// - offset: ` 20`(x86)/` 32`(x86_64)
40    /// - type_size: `  2`(x86)/`  2`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "currentLod"))]
42    #[cfg_attr(feature = "serde", serde(rename = "currentLod"))]
43    pub m_currentLod: i16,
44    /// # C++ Info
45    /// - name: `numTracksInLod`(ctype: `hkInt16`)
46    /// - offset: ` 22`(x86)/` 34`(x86_64)
47    /// - type_size: `  2`(x86)/`  2`(x86_64)
48    /// - flags: `SERIALIZE_IGNORED`
49    #[cfg_attr(feature = "json_schema", schemars(rename = "numTracksInLod"))]
50    #[cfg_attr(feature = "serde", serde(rename = "numTracksInLod"))]
51    pub m_numTracksInLod: i16,
52    /// # C++ Info
53    /// - name: `name`(ctype: `hkStringPtr`)
54    /// - offset: ` 24`(x86)/` 40`(x86_64)
55    /// - type_size: `  4`(x86)/`  8`(x86_64)
56    #[cfg_attr(feature = "serde", serde(borrow))]
57    #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
58    #[cfg_attr(feature = "serde", serde(rename = "name"))]
59    pub m_name: StringPtr<'a>,
60    /// # C++ Info
61    /// - name: `ragdollDriver`(ctype: `void*`)
62    /// - offset: ` 28`(x86)/` 48`(x86_64)
63    /// - type_size: `  4`(x86)/`  8`(x86_64)
64    /// - flags: `SERIALIZE_IGNORED`
65    #[cfg_attr(feature = "json_schema", schemars(rename = "ragdollDriver"))]
66    #[cfg_attr(feature = "serde", serde(rename = "ragdollDriver"))]
67    pub m_ragdollDriver: Pointer,
68    /// # C++ Info
69    /// - name: `characterControllerDriver`(ctype: `void*`)
70    /// - offset: ` 32`(x86)/` 56`(x86_64)
71    /// - type_size: `  4`(x86)/`  8`(x86_64)
72    /// - flags: `SERIALIZE_IGNORED`
73    #[cfg_attr(feature = "json_schema", schemars(rename = "characterControllerDriver"))]
74    #[cfg_attr(feature = "serde", serde(rename = "characterControllerDriver"))]
75    pub m_characterControllerDriver: Pointer,
76    /// # C++ Info
77    /// - name: `footIkDriver`(ctype: `void*`)
78    /// - offset: ` 36`(x86)/` 64`(x86_64)
79    /// - type_size: `  4`(x86)/`  8`(x86_64)
80    /// - flags: `SERIALIZE_IGNORED`
81    #[cfg_attr(feature = "json_schema", schemars(rename = "footIkDriver"))]
82    #[cfg_attr(feature = "serde", serde(rename = "footIkDriver"))]
83    pub m_footIkDriver: Pointer,
84    /// # C++ Info
85    /// - name: `handIkDriver`(ctype: `void*`)
86    /// - offset: ` 40`(x86)/` 72`(x86_64)
87    /// - type_size: `  4`(x86)/`  8`(x86_64)
88    /// - flags: `SERIALIZE_IGNORED`
89    #[cfg_attr(feature = "json_schema", schemars(rename = "handIkDriver"))]
90    #[cfg_attr(feature = "serde", serde(rename = "handIkDriver"))]
91    pub m_handIkDriver: Pointer,
92    /// # C++ Info
93    /// - name: `setup`(ctype: `struct hkbCharacterSetup*`)
94    /// - offset: ` 44`(x86)/` 80`(x86_64)
95    /// - type_size: `  4`(x86)/`  8`(x86_64)
96    #[cfg_attr(feature = "json_schema", schemars(rename = "setup"))]
97    #[cfg_attr(feature = "serde", serde(rename = "setup"))]
98    pub m_setup: Pointer,
99    /// # C++ Info
100    /// - name: `behaviorGraph`(ctype: `struct hkbBehaviorGraph*`)
101    /// - offset: ` 48`(x86)/` 88`(x86_64)
102    /// - type_size: `  4`(x86)/`  8`(x86_64)
103    #[cfg_attr(feature = "json_schema", schemars(rename = "behaviorGraph"))]
104    #[cfg_attr(feature = "serde", serde(rename = "behaviorGraph"))]
105    pub m_behaviorGraph: Pointer,
106    /// # C++ Info
107    /// - name: `projectData`(ctype: `struct hkbProjectData*`)
108    /// - offset: ` 52`(x86)/` 96`(x86_64)
109    /// - type_size: `  4`(x86)/`  8`(x86_64)
110    #[cfg_attr(feature = "json_schema", schemars(rename = "projectData"))]
111    #[cfg_attr(feature = "serde", serde(rename = "projectData"))]
112    pub m_projectData: Pointer,
113    /// # C++ Info
114    /// - name: `animationBindingSet`(ctype: `void*`)
115    /// - offset: ` 56`(x86)/`104`(x86_64)
116    /// - type_size: `  4`(x86)/`  8`(x86_64)
117    /// - flags: `SERIALIZE_IGNORED`
118    #[cfg_attr(feature = "json_schema", schemars(rename = "animationBindingSet"))]
119    #[cfg_attr(feature = "serde", serde(rename = "animationBindingSet"))]
120    pub m_animationBindingSet: Pointer,
121    /// # C++ Info
122    /// - name: `raycastInterface`(ctype: `void*`)
123    /// - offset: ` 60`(x86)/`112`(x86_64)
124    /// - type_size: `  4`(x86)/`  8`(x86_64)
125    /// - flags: `SERIALIZE_IGNORED`
126    #[cfg_attr(feature = "json_schema", schemars(rename = "raycastInterface"))]
127    #[cfg_attr(feature = "serde", serde(rename = "raycastInterface"))]
128    pub m_raycastInterface: Pointer,
129    /// # C++ Info
130    /// - name: `world`(ctype: `void*`)
131    /// - offset: ` 64`(x86)/`120`(x86_64)
132    /// - type_size: `  4`(x86)/`  8`(x86_64)
133    /// - flags: `NOT_OWNED|SERIALIZE_IGNORED`
134    #[cfg_attr(feature = "json_schema", schemars(rename = "world"))]
135    #[cfg_attr(feature = "serde", serde(rename = "world"))]
136    pub m_world: Pointer,
137    /// # C++ Info
138    /// - name: `eventQueue`(ctype: `void*`)
139    /// - offset: ` 68`(x86)/`128`(x86_64)
140    /// - type_size: `  4`(x86)/`  8`(x86_64)
141    /// - flags: `SERIALIZE_IGNORED`
142    #[cfg_attr(feature = "json_schema", schemars(rename = "eventQueue"))]
143    #[cfg_attr(feature = "serde", serde(rename = "eventQueue"))]
144    pub m_eventQueue: Pointer,
145    /// # C++ Info
146    /// - name: `worldFromModel`(ctype: `void*`)
147    /// - offset: ` 72`(x86)/`136`(x86_64)
148    /// - type_size: `  4`(x86)/`  8`(x86_64)
149    /// - flags: `SERIALIZE_IGNORED`
150    #[cfg_attr(feature = "json_schema", schemars(rename = "worldFromModel"))]
151    #[cfg_attr(feature = "serde", serde(rename = "worldFromModel"))]
152    pub m_worldFromModel: Pointer,
153    /// # C++ Info
154    /// - name: `poseLocal`(ctype: `hkSimpleArray<void>`)
155    /// - offset: ` 76`(x86)/`144`(x86_64)
156    /// - type_size: `  8`(x86)/` 12`(x86_64)
157    /// - flags: `SERIALIZE_IGNORED`
158    #[cfg_attr(feature = "json_schema", schemars(rename = "poseLocal"))]
159    #[cfg_attr(feature = "serde", serde(rename = "poseLocal"))]
160    pub m_poseLocal: Vec<()>,
161    /// # C++ Info
162    /// - name: `deleteWorldFromModel`(ctype: `hkBool`)
163    /// - offset: ` 84`(x86)/`156`(x86_64)
164    /// - type_size: `  1`(x86)/`  1`(x86_64)
165    /// - flags: `SERIALIZE_IGNORED`
166    #[cfg_attr(feature = "json_schema", schemars(rename = "deleteWorldFromModel"))]
167    #[cfg_attr(feature = "serde", serde(rename = "deleteWorldFromModel"))]
168    pub m_deleteWorldFromModel: bool,
169    /// # C++ Info
170    /// - name: `deletePoseLocal`(ctype: `hkBool`)
171    /// - offset: ` 85`(x86)/`157`(x86_64)
172    /// - type_size: `  1`(x86)/`  1`(x86_64)
173    /// - flags: `SERIALIZE_IGNORED`
174    #[cfg_attr(feature = "json_schema", schemars(rename = "deletePoseLocal"))]
175    #[cfg_attr(feature = "serde", serde(rename = "deletePoseLocal"))]
176    pub m_deletePoseLocal: bool,
177}
178const _: () = {
179    use havok_serde as _serde;
180    impl<'a> _serde::HavokClass for hkbCharacter<'a> {
181        #[inline]
182        fn name(&self) -> &'static str {
183            "hkbCharacter"
184        }
185        #[inline]
186        fn signature(&self) -> _serde::__private::Signature {
187            _serde::__private::Signature::new(0x3088a5c5)
188        }
189        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
190        fn deps_indexes(&self) -> Vec<usize> {
191            let mut v = Vec::new();
192            v.extend(self.m_nearbyCharacters.iter().map(|ptr| ptr.get()));
193            v.push(self.m_ragdollDriver.get());
194            v.push(self.m_characterControllerDriver.get());
195            v.push(self.m_footIkDriver.get());
196            v.push(self.m_handIkDriver.get());
197            v.push(self.m_setup.get());
198            v.push(self.m_behaviorGraph.get());
199            v.push(self.m_projectData.get());
200            v.push(self.m_animationBindingSet.get());
201            v.push(self.m_raycastInterface.get());
202            v.push(self.m_world.get());
203            v.push(self.m_eventQueue.get());
204            v.push(self.m_worldFromModel.get());
205            v
206        }
207    }
208    impl<'a> _serde::Serialize for hkbCharacter<'a> {
209        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
210        where
211            S: _serde::ser::Serializer,
212        {
213            let class_meta = self
214                .__ptr
215                .map(|name| (name, _serde::__private::Signature::new(0x3088a5c5)));
216            let mut serializer = __serializer
217                .serialize_struct("hkbCharacter", class_meta, (88u64, 160u64))?;
218            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
219            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
220            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
221            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
222            serializer
223                .serialize_array_field(
224                    "nearbyCharacters",
225                    &self.m_nearbyCharacters,
226                    TypeSize::NonPtr,
227                )?;
228            serializer.serialize_field("currentLod", &self.m_currentLod)?;
229            serializer.skip_field("numTracksInLod", &self.m_numTracksInLod)?;
230            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
231            serializer.serialize_field("name", &self.m_name)?;
232            serializer.skip_field("ragdollDriver", &self.m_ragdollDriver)?;
233            serializer
234                .skip_field(
235                    "characterControllerDriver",
236                    &self.m_characterControllerDriver,
237                )?;
238            serializer.skip_field("footIkDriver", &self.m_footIkDriver)?;
239            serializer.skip_field("handIkDriver", &self.m_handIkDriver)?;
240            serializer.serialize_field("setup", &self.m_setup)?;
241            serializer.serialize_field("behaviorGraph", &self.m_behaviorGraph)?;
242            serializer.serialize_field("projectData", &self.m_projectData)?;
243            serializer.skip_field("animationBindingSet", &self.m_animationBindingSet)?;
244            serializer.skip_field("raycastInterface", &self.m_raycastInterface)?;
245            serializer.skip_field("world", &self.m_world)?;
246            serializer.skip_field("eventQueue", &self.m_eventQueue)?;
247            serializer.skip_field("worldFromModel", &self.m_worldFromModel)?;
248            serializer.skip_field("poseLocal", &self.m_poseLocal)?;
249            serializer.skip_field("deleteWorldFromModel", &self.m_deleteWorldFromModel)?;
250            serializer.skip_field("deletePoseLocal", &self.m_deletePoseLocal)?;
251            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
252            serializer.end()
253        }
254    }
255};
256#[doc(hidden)]
257#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
258const _: () = {
259    use havok_serde as _serde;
260    #[automatically_derived]
261    impl<'de> _serde::Deserialize<'de> for hkbCharacter<'de> {
262        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
263        where
264            __D: _serde::Deserializer<'de>,
265        {
266            #[allow(non_camel_case_types)]
267            enum __Field {
268                m_nearbyCharacters,
269                m_currentLod,
270                m_name,
271                m_setup,
272                m_behaviorGraph,
273                m_projectData,
274                __ignore,
275            }
276            struct __FieldVisitor;
277            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
278                type Value = __Field;
279                fn expecting(
280                    &self,
281                    __formatter: &mut core::fmt::Formatter,
282                ) -> core::fmt::Result {
283                    core::fmt::Formatter::write_str(__formatter, "field identifier")
284                }
285                /// Intended for use in XML.
286                #[allow(clippy::match_single_binding)]
287                #[allow(clippy::reversed_empty_ranges)]
288                #[allow(clippy::single_match)]
289                fn visit_key<__E>(
290                    self,
291                    __value: &str,
292                ) -> core::result::Result<Self::Value, __E>
293                where
294                    __E: _serde::de::Error,
295                {
296                    match __value {
297                        "nearbyCharacters" => Ok(__Field::m_nearbyCharacters),
298                        "currentLod" => Ok(__Field::m_currentLod),
299                        "name" => Ok(__Field::m_name),
300                        "setup" => Ok(__Field::m_setup),
301                        "behaviorGraph" => Ok(__Field::m_behaviorGraph),
302                        "projectData" => Ok(__Field::m_projectData),
303                        _ => Ok(__Field::__ignore),
304                    }
305                }
306            }
307            impl<'de> _serde::Deserialize<'de> for __Field {
308                #[inline]
309                fn deserialize<__D>(
310                    __deserializer: __D,
311                ) -> core::result::Result<Self, __D::Error>
312                where
313                    __D: _serde::Deserializer<'de>,
314                {
315                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
316                }
317            }
318            struct __hkbCharacterVisitor<'de> {
319                marker: _serde::__private::PhantomData<hkbCharacter<'de>>,
320                lifetime: _serde::__private::PhantomData<&'de ()>,
321            }
322            #[allow(clippy::match_single_binding)]
323            #[allow(clippy::reversed_empty_ranges)]
324            #[allow(clippy::single_match)]
325            impl<'de> _serde::de::Visitor<'de> for __hkbCharacterVisitor<'de> {
326                type Value = hkbCharacter<'de>;
327                fn expecting(
328                    &self,
329                    __formatter: &mut core::fmt::Formatter,
330                ) -> core::fmt::Result {
331                    core::fmt::Formatter::write_str(__formatter, "struct hkbCharacter")
332                }
333                fn visit_struct_for_bytes<__A>(
334                    self,
335                    mut __map: __A,
336                ) -> _serde::__private::Result<Self::Value, __A::Error>
337                where
338                    __A: _serde::de::MapAccess<'de>,
339                {
340                    let __ptr = __A::class_ptr(&mut __map);
341                    let parent = __A::parent_value(&mut __map)?;
342                    let mut m_nearbyCharacters: _serde::__private::Option<
343                        Vec<Pointer>,
344                    > = _serde::__private::None;
345                    let mut m_currentLod: _serde::__private::Option<i16> = _serde::__private::None;
346                    let mut m_numTracksInLod: _serde::__private::Option<i16> = _serde::__private::None;
347                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
348                    let mut m_ragdollDriver: _serde::__private::Option<Pointer> = _serde::__private::None;
349                    let mut m_characterControllerDriver: _serde::__private::Option<
350                        Pointer,
351                    > = _serde::__private::None;
352                    let mut m_footIkDriver: _serde::__private::Option<Pointer> = _serde::__private::None;
353                    let mut m_handIkDriver: _serde::__private::Option<Pointer> = _serde::__private::None;
354                    let mut m_setup: _serde::__private::Option<Pointer> = _serde::__private::None;
355                    let mut m_behaviorGraph: _serde::__private::Option<Pointer> = _serde::__private::None;
356                    let mut m_projectData: _serde::__private::Option<Pointer> = _serde::__private::None;
357                    let mut m_animationBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
358                    let mut m_raycastInterface: _serde::__private::Option<Pointer> = _serde::__private::None;
359                    let mut m_world: _serde::__private::Option<Pointer> = _serde::__private::None;
360                    let mut m_eventQueue: _serde::__private::Option<Pointer> = _serde::__private::None;
361                    let mut m_worldFromModel: _serde::__private::Option<Pointer> = _serde::__private::None;
362                    let mut m_poseLocal: _serde::__private::Option<Vec<()>> = _serde::__private::None;
363                    let mut m_deleteWorldFromModel: _serde::__private::Option<bool> = _serde::__private::None;
364                    let mut m_deletePoseLocal: _serde::__private::Option<bool> = _serde::__private::None;
365                    for i in 0..19usize {
366                        match i {
367                            0usize => {
368                                if _serde::__private::Option::is_some(&m_nearbyCharacters) {
369                                    return _serde::__private::Err(
370                                        <__A::Error as _serde::de::Error>::duplicate_field(
371                                            "nearbyCharacters",
372                                        ),
373                                    );
374                                }
375                                m_nearbyCharacters = _serde::__private::Some(
376                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
377                                        _serde::__private::Ok(__val) => __val,
378                                        _serde::__private::Err(__err) => {
379                                            return _serde::__private::Err(__err);
380                                        }
381                                    },
382                                );
383                            }
384                            1usize => {
385                                if _serde::__private::Option::is_some(&m_currentLod) {
386                                    return _serde::__private::Err(
387                                        <__A::Error as _serde::de::Error>::duplicate_field(
388                                            "currentLod",
389                                        ),
390                                    );
391                                }
392                                m_currentLod = _serde::__private::Some(
393                                    match __A::next_value::<i16>(&mut __map) {
394                                        _serde::__private::Ok(__val) => __val,
395                                        _serde::__private::Err(__err) => {
396                                            return _serde::__private::Err(__err);
397                                        }
398                                    },
399                                );
400                            }
401                            2usize => {
402                                if _serde::__private::Option::is_some(&m_numTracksInLod) {
403                                    return _serde::__private::Err(
404                                        <__A::Error as _serde::de::Error>::duplicate_field(
405                                            "numTracksInLod",
406                                        ),
407                                    );
408                                }
409                                m_numTracksInLod = _serde::__private::Some(
410                                    match __A::next_value::<i16>(&mut __map) {
411                                        _serde::__private::Ok(__val) => __val,
412                                        _serde::__private::Err(__err) => {
413                                            return _serde::__private::Err(__err);
414                                        }
415                                    },
416                                );
417                            }
418                            3usize => {
419                                if _serde::__private::Option::is_some(&m_name) {
420                                    return _serde::__private::Err(
421                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
422                                    );
423                                }
424                                __A::pad(&mut __map, 0usize, 4usize)?;
425                                m_name = _serde::__private::Some(
426                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
427                                        _serde::__private::Ok(__val) => __val,
428                                        _serde::__private::Err(__err) => {
429                                            return _serde::__private::Err(__err);
430                                        }
431                                    },
432                                );
433                            }
434                            4usize => {
435                                if _serde::__private::Option::is_some(&m_ragdollDriver) {
436                                    return _serde::__private::Err(
437                                        <__A::Error as _serde::de::Error>::duplicate_field(
438                                            "ragdollDriver",
439                                        ),
440                                    );
441                                }
442                                m_ragdollDriver = _serde::__private::Some(
443                                    match __A::next_value::<Pointer>(&mut __map) {
444                                        _serde::__private::Ok(__val) => __val,
445                                        _serde::__private::Err(__err) => {
446                                            return _serde::__private::Err(__err);
447                                        }
448                                    },
449                                );
450                            }
451                            5usize => {
452                                if _serde::__private::Option::is_some(
453                                    &m_characterControllerDriver,
454                                ) {
455                                    return _serde::__private::Err(
456                                        <__A::Error as _serde::de::Error>::duplicate_field(
457                                            "characterControllerDriver",
458                                        ),
459                                    );
460                                }
461                                m_characterControllerDriver = _serde::__private::Some(
462                                    match __A::next_value::<Pointer>(&mut __map) {
463                                        _serde::__private::Ok(__val) => __val,
464                                        _serde::__private::Err(__err) => {
465                                            return _serde::__private::Err(__err);
466                                        }
467                                    },
468                                );
469                            }
470                            6usize => {
471                                if _serde::__private::Option::is_some(&m_footIkDriver) {
472                                    return _serde::__private::Err(
473                                        <__A::Error as _serde::de::Error>::duplicate_field(
474                                            "footIkDriver",
475                                        ),
476                                    );
477                                }
478                                m_footIkDriver = _serde::__private::Some(
479                                    match __A::next_value::<Pointer>(&mut __map) {
480                                        _serde::__private::Ok(__val) => __val,
481                                        _serde::__private::Err(__err) => {
482                                            return _serde::__private::Err(__err);
483                                        }
484                                    },
485                                );
486                            }
487                            7usize => {
488                                if _serde::__private::Option::is_some(&m_handIkDriver) {
489                                    return _serde::__private::Err(
490                                        <__A::Error as _serde::de::Error>::duplicate_field(
491                                            "handIkDriver",
492                                        ),
493                                    );
494                                }
495                                m_handIkDriver = _serde::__private::Some(
496                                    match __A::next_value::<Pointer>(&mut __map) {
497                                        _serde::__private::Ok(__val) => __val,
498                                        _serde::__private::Err(__err) => {
499                                            return _serde::__private::Err(__err);
500                                        }
501                                    },
502                                );
503                            }
504                            8usize => {
505                                if _serde::__private::Option::is_some(&m_setup) {
506                                    return _serde::__private::Err(
507                                        <__A::Error as _serde::de::Error>::duplicate_field("setup"),
508                                    );
509                                }
510                                m_setup = _serde::__private::Some(
511                                    match __A::next_value::<Pointer>(&mut __map) {
512                                        _serde::__private::Ok(__val) => __val,
513                                        _serde::__private::Err(__err) => {
514                                            return _serde::__private::Err(__err);
515                                        }
516                                    },
517                                );
518                            }
519                            9usize => {
520                                if _serde::__private::Option::is_some(&m_behaviorGraph) {
521                                    return _serde::__private::Err(
522                                        <__A::Error as _serde::de::Error>::duplicate_field(
523                                            "behaviorGraph",
524                                        ),
525                                    );
526                                }
527                                m_behaviorGraph = _serde::__private::Some(
528                                    match __A::next_value::<Pointer>(&mut __map) {
529                                        _serde::__private::Ok(__val) => __val,
530                                        _serde::__private::Err(__err) => {
531                                            return _serde::__private::Err(__err);
532                                        }
533                                    },
534                                );
535                            }
536                            10usize => {
537                                if _serde::__private::Option::is_some(&m_projectData) {
538                                    return _serde::__private::Err(
539                                        <__A::Error as _serde::de::Error>::duplicate_field(
540                                            "projectData",
541                                        ),
542                                    );
543                                }
544                                m_projectData = _serde::__private::Some(
545                                    match __A::next_value::<Pointer>(&mut __map) {
546                                        _serde::__private::Ok(__val) => __val,
547                                        _serde::__private::Err(__err) => {
548                                            return _serde::__private::Err(__err);
549                                        }
550                                    },
551                                );
552                            }
553                            11usize => {
554                                if _serde::__private::Option::is_some(
555                                    &m_animationBindingSet,
556                                ) {
557                                    return _serde::__private::Err(
558                                        <__A::Error as _serde::de::Error>::duplicate_field(
559                                            "animationBindingSet",
560                                        ),
561                                    );
562                                }
563                                m_animationBindingSet = _serde::__private::Some(
564                                    match __A::next_value::<Pointer>(&mut __map) {
565                                        _serde::__private::Ok(__val) => __val,
566                                        _serde::__private::Err(__err) => {
567                                            return _serde::__private::Err(__err);
568                                        }
569                                    },
570                                );
571                            }
572                            12usize => {
573                                if _serde::__private::Option::is_some(&m_raycastInterface) {
574                                    return _serde::__private::Err(
575                                        <__A::Error as _serde::de::Error>::duplicate_field(
576                                            "raycastInterface",
577                                        ),
578                                    );
579                                }
580                                m_raycastInterface = _serde::__private::Some(
581                                    match __A::next_value::<Pointer>(&mut __map) {
582                                        _serde::__private::Ok(__val) => __val,
583                                        _serde::__private::Err(__err) => {
584                                            return _serde::__private::Err(__err);
585                                        }
586                                    },
587                                );
588                            }
589                            13usize => {
590                                if _serde::__private::Option::is_some(&m_world) {
591                                    return _serde::__private::Err(
592                                        <__A::Error as _serde::de::Error>::duplicate_field("world"),
593                                    );
594                                }
595                                m_world = _serde::__private::Some(
596                                    match __A::next_value::<Pointer>(&mut __map) {
597                                        _serde::__private::Ok(__val) => __val,
598                                        _serde::__private::Err(__err) => {
599                                            return _serde::__private::Err(__err);
600                                        }
601                                    },
602                                );
603                            }
604                            14usize => {
605                                if _serde::__private::Option::is_some(&m_eventQueue) {
606                                    return _serde::__private::Err(
607                                        <__A::Error as _serde::de::Error>::duplicate_field(
608                                            "eventQueue",
609                                        ),
610                                    );
611                                }
612                                m_eventQueue = _serde::__private::Some(
613                                    match __A::next_value::<Pointer>(&mut __map) {
614                                        _serde::__private::Ok(__val) => __val,
615                                        _serde::__private::Err(__err) => {
616                                            return _serde::__private::Err(__err);
617                                        }
618                                    },
619                                );
620                            }
621                            15usize => {
622                                if _serde::__private::Option::is_some(&m_worldFromModel) {
623                                    return _serde::__private::Err(
624                                        <__A::Error as _serde::de::Error>::duplicate_field(
625                                            "worldFromModel",
626                                        ),
627                                    );
628                                }
629                                m_worldFromModel = _serde::__private::Some(
630                                    match __A::next_value::<Pointer>(&mut __map) {
631                                        _serde::__private::Ok(__val) => __val,
632                                        _serde::__private::Err(__err) => {
633                                            return _serde::__private::Err(__err);
634                                        }
635                                    },
636                                );
637                            }
638                            16usize => {
639                                if _serde::__private::Option::is_some(&m_poseLocal) {
640                                    return _serde::__private::Err(
641                                        <__A::Error as _serde::de::Error>::duplicate_field(
642                                            "poseLocal",
643                                        ),
644                                    );
645                                }
646                                m_poseLocal = _serde::__private::Some(
647                                    match __A::next_value::<Vec<()>>(&mut __map) {
648                                        _serde::__private::Ok(__val) => __val,
649                                        _serde::__private::Err(__err) => {
650                                            return _serde::__private::Err(__err);
651                                        }
652                                    },
653                                );
654                            }
655                            17usize => {
656                                if _serde::__private::Option::is_some(
657                                    &m_deleteWorldFromModel,
658                                ) {
659                                    return _serde::__private::Err(
660                                        <__A::Error as _serde::de::Error>::duplicate_field(
661                                            "deleteWorldFromModel",
662                                        ),
663                                    );
664                                }
665                                m_deleteWorldFromModel = _serde::__private::Some(
666                                    match __A::next_value::<bool>(&mut __map) {
667                                        _serde::__private::Ok(__val) => __val,
668                                        _serde::__private::Err(__err) => {
669                                            return _serde::__private::Err(__err);
670                                        }
671                                    },
672                                );
673                            }
674                            18usize => {
675                                if _serde::__private::Option::is_some(&m_deletePoseLocal) {
676                                    return _serde::__private::Err(
677                                        <__A::Error as _serde::de::Error>::duplicate_field(
678                                            "deletePoseLocal",
679                                        ),
680                                    );
681                                }
682                                m_deletePoseLocal = _serde::__private::Some(
683                                    match __A::next_value::<bool>(&mut __map) {
684                                        _serde::__private::Ok(__val) => __val,
685                                        _serde::__private::Err(__err) => {
686                                            return _serde::__private::Err(__err);
687                                        }
688                                    },
689                                );
690                            }
691                            _ => {}
692                        }
693                    }
694                    __A::pad(&mut __map, 2usize, 2usize)?;
695                    let m_nearbyCharacters = match m_nearbyCharacters {
696                        _serde::__private::Some(__field) => __field,
697                        _serde::__private::None => {
698                            return _serde::__private::Err(
699                                <__A::Error as _serde::de::Error>::missing_field(
700                                    "nearbyCharacters",
701                                ),
702                            );
703                        }
704                    };
705                    let m_currentLod = match m_currentLod {
706                        _serde::__private::Some(__field) => __field,
707                        _serde::__private::None => {
708                            return _serde::__private::Err(
709                                <__A::Error as _serde::de::Error>::missing_field(
710                                    "currentLod",
711                                ),
712                            );
713                        }
714                    };
715                    let m_numTracksInLod = match m_numTracksInLod {
716                        _serde::__private::Some(__field) => __field,
717                        _serde::__private::None => {
718                            return _serde::__private::Err(
719                                <__A::Error as _serde::de::Error>::missing_field(
720                                    "numTracksInLod",
721                                ),
722                            );
723                        }
724                    };
725                    let m_name = match m_name {
726                        _serde::__private::Some(__field) => __field,
727                        _serde::__private::None => {
728                            return _serde::__private::Err(
729                                <__A::Error as _serde::de::Error>::missing_field("name"),
730                            );
731                        }
732                    };
733                    let m_ragdollDriver = match m_ragdollDriver {
734                        _serde::__private::Some(__field) => __field,
735                        _serde::__private::None => {
736                            return _serde::__private::Err(
737                                <__A::Error as _serde::de::Error>::missing_field(
738                                    "ragdollDriver",
739                                ),
740                            );
741                        }
742                    };
743                    let m_characterControllerDriver = match m_characterControllerDriver {
744                        _serde::__private::Some(__field) => __field,
745                        _serde::__private::None => {
746                            return _serde::__private::Err(
747                                <__A::Error as _serde::de::Error>::missing_field(
748                                    "characterControllerDriver",
749                                ),
750                            );
751                        }
752                    };
753                    let m_footIkDriver = match m_footIkDriver {
754                        _serde::__private::Some(__field) => __field,
755                        _serde::__private::None => {
756                            return _serde::__private::Err(
757                                <__A::Error as _serde::de::Error>::missing_field(
758                                    "footIkDriver",
759                                ),
760                            );
761                        }
762                    };
763                    let m_handIkDriver = match m_handIkDriver {
764                        _serde::__private::Some(__field) => __field,
765                        _serde::__private::None => {
766                            return _serde::__private::Err(
767                                <__A::Error as _serde::de::Error>::missing_field(
768                                    "handIkDriver",
769                                ),
770                            );
771                        }
772                    };
773                    let m_setup = match m_setup {
774                        _serde::__private::Some(__field) => __field,
775                        _serde::__private::None => {
776                            return _serde::__private::Err(
777                                <__A::Error as _serde::de::Error>::missing_field("setup"),
778                            );
779                        }
780                    };
781                    let m_behaviorGraph = match m_behaviorGraph {
782                        _serde::__private::Some(__field) => __field,
783                        _serde::__private::None => {
784                            return _serde::__private::Err(
785                                <__A::Error as _serde::de::Error>::missing_field(
786                                    "behaviorGraph",
787                                ),
788                            );
789                        }
790                    };
791                    let m_projectData = match m_projectData {
792                        _serde::__private::Some(__field) => __field,
793                        _serde::__private::None => {
794                            return _serde::__private::Err(
795                                <__A::Error as _serde::de::Error>::missing_field(
796                                    "projectData",
797                                ),
798                            );
799                        }
800                    };
801                    let m_animationBindingSet = match m_animationBindingSet {
802                        _serde::__private::Some(__field) => __field,
803                        _serde::__private::None => {
804                            return _serde::__private::Err(
805                                <__A::Error as _serde::de::Error>::missing_field(
806                                    "animationBindingSet",
807                                ),
808                            );
809                        }
810                    };
811                    let m_raycastInterface = match m_raycastInterface {
812                        _serde::__private::Some(__field) => __field,
813                        _serde::__private::None => {
814                            return _serde::__private::Err(
815                                <__A::Error as _serde::de::Error>::missing_field(
816                                    "raycastInterface",
817                                ),
818                            );
819                        }
820                    };
821                    let m_world = match m_world {
822                        _serde::__private::Some(__field) => __field,
823                        _serde::__private::None => {
824                            return _serde::__private::Err(
825                                <__A::Error as _serde::de::Error>::missing_field("world"),
826                            );
827                        }
828                    };
829                    let m_eventQueue = match m_eventQueue {
830                        _serde::__private::Some(__field) => __field,
831                        _serde::__private::None => {
832                            return _serde::__private::Err(
833                                <__A::Error as _serde::de::Error>::missing_field(
834                                    "eventQueue",
835                                ),
836                            );
837                        }
838                    };
839                    let m_worldFromModel = match m_worldFromModel {
840                        _serde::__private::Some(__field) => __field,
841                        _serde::__private::None => {
842                            return _serde::__private::Err(
843                                <__A::Error as _serde::de::Error>::missing_field(
844                                    "worldFromModel",
845                                ),
846                            );
847                        }
848                    };
849                    let m_poseLocal = match m_poseLocal {
850                        _serde::__private::Some(__field) => __field,
851                        _serde::__private::None => {
852                            return _serde::__private::Err(
853                                <__A::Error as _serde::de::Error>::missing_field(
854                                    "poseLocal",
855                                ),
856                            );
857                        }
858                    };
859                    let m_deleteWorldFromModel = match m_deleteWorldFromModel {
860                        _serde::__private::Some(__field) => __field,
861                        _serde::__private::None => {
862                            return _serde::__private::Err(
863                                <__A::Error as _serde::de::Error>::missing_field(
864                                    "deleteWorldFromModel",
865                                ),
866                            );
867                        }
868                    };
869                    let m_deletePoseLocal = match m_deletePoseLocal {
870                        _serde::__private::Some(__field) => __field,
871                        _serde::__private::None => {
872                            return _serde::__private::Err(
873                                <__A::Error as _serde::de::Error>::missing_field(
874                                    "deletePoseLocal",
875                                ),
876                            );
877                        }
878                    };
879                    _serde::__private::Ok(hkbCharacter {
880                        __ptr,
881                        parent,
882                        m_nearbyCharacters,
883                        m_currentLod,
884                        m_numTracksInLod,
885                        m_name,
886                        m_ragdollDriver,
887                        m_characterControllerDriver,
888                        m_footIkDriver,
889                        m_handIkDriver,
890                        m_setup,
891                        m_behaviorGraph,
892                        m_projectData,
893                        m_animationBindingSet,
894                        m_raycastInterface,
895                        m_world,
896                        m_eventQueue,
897                        m_worldFromModel,
898                        m_poseLocal,
899                        m_deleteWorldFromModel,
900                        m_deletePoseLocal,
901                    })
902                }
903                #[allow(clippy::manual_unwrap_or_default)]
904                fn visit_struct<__A>(
905                    self,
906                    mut __map: __A,
907                ) -> _serde::__private::Result<Self::Value, __A::Error>
908                where
909                    __A: _serde::de::MapAccess<'de>,
910                {
911                    let mut m_nearbyCharacters: _serde::__private::Option<
912                        Vec<Pointer>,
913                    > = _serde::__private::None;
914                    let mut m_currentLod: _serde::__private::Option<i16> = _serde::__private::None;
915                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
916                    let mut m_setup: _serde::__private::Option<Pointer> = _serde::__private::None;
917                    let mut m_behaviorGraph: _serde::__private::Option<Pointer> = _serde::__private::None;
918                    let mut m_projectData: _serde::__private::Option<Pointer> = _serde::__private::None;
919                    while let _serde::__private::Some(__key) = {
920                        __A::next_key::<__Field>(&mut __map)?
921                    } {
922                        match __key {
923                            __Field::m_nearbyCharacters => {
924                                #[cfg(
925                                    any(feature = "strict", feature = "ignore_duplicates")
926                                )]
927                                if _serde::__private::Option::is_some(&m_nearbyCharacters) {
928                                    #[cfg(feature = "ignore_duplicates")]
929                                    {
930                                        __A::skip_value(&mut __map)?;
931                                        continue;
932                                    }
933                                    #[cfg(feature = "strict")]
934                                    return _serde::__private::Err(
935                                        <__A::Error as _serde::de::Error>::duplicate_field(
936                                            "nearbyCharacters",
937                                        ),
938                                    );
939                                }
940                                m_nearbyCharacters = _serde::__private::Some(
941                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
942                                        _serde::__private::Ok(__val) => __val,
943                                        _serde::__private::Err(__err) => {
944                                            return _serde::__private::Err(__err);
945                                        }
946                                    },
947                                );
948                            }
949                            __Field::m_currentLod => {
950                                #[cfg(
951                                    any(feature = "strict", feature = "ignore_duplicates")
952                                )]
953                                if _serde::__private::Option::is_some(&m_currentLod) {
954                                    #[cfg(feature = "ignore_duplicates")]
955                                    {
956                                        __A::skip_value(&mut __map)?;
957                                        continue;
958                                    }
959                                    #[cfg(feature = "strict")]
960                                    return _serde::__private::Err(
961                                        <__A::Error as _serde::de::Error>::duplicate_field(
962                                            "currentLod",
963                                        ),
964                                    );
965                                }
966                                m_currentLod = _serde::__private::Some(
967                                    match __A::next_value::<i16>(&mut __map) {
968                                        _serde::__private::Ok(__val) => __val,
969                                        _serde::__private::Err(__err) => {
970                                            return _serde::__private::Err(__err);
971                                        }
972                                    },
973                                );
974                            }
975                            __Field::m_name => {
976                                #[cfg(
977                                    any(feature = "strict", feature = "ignore_duplicates")
978                                )]
979                                if _serde::__private::Option::is_some(&m_name) {
980                                    #[cfg(feature = "ignore_duplicates")]
981                                    {
982                                        __A::skip_value(&mut __map)?;
983                                        continue;
984                                    }
985                                    #[cfg(feature = "strict")]
986                                    return _serde::__private::Err(
987                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
988                                    );
989                                }
990                                m_name = _serde::__private::Some(
991                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
992                                        _serde::__private::Ok(__val) => __val,
993                                        _serde::__private::Err(__err) => {
994                                            return _serde::__private::Err(__err);
995                                        }
996                                    },
997                                );
998                            }
999                            __Field::m_setup => {
1000                                #[cfg(
1001                                    any(feature = "strict", feature = "ignore_duplicates")
1002                                )]
1003                                if _serde::__private::Option::is_some(&m_setup) {
1004                                    #[cfg(feature = "ignore_duplicates")]
1005                                    {
1006                                        __A::skip_value(&mut __map)?;
1007                                        continue;
1008                                    }
1009                                    #[cfg(feature = "strict")]
1010                                    return _serde::__private::Err(
1011                                        <__A::Error as _serde::de::Error>::duplicate_field("setup"),
1012                                    );
1013                                }
1014                                m_setup = _serde::__private::Some(
1015                                    match __A::next_value::<Pointer>(&mut __map) {
1016                                        _serde::__private::Ok(__val) => __val,
1017                                        _serde::__private::Err(__err) => {
1018                                            return _serde::__private::Err(__err);
1019                                        }
1020                                    },
1021                                );
1022                            }
1023                            __Field::m_behaviorGraph => {
1024                                #[cfg(
1025                                    any(feature = "strict", feature = "ignore_duplicates")
1026                                )]
1027                                if _serde::__private::Option::is_some(&m_behaviorGraph) {
1028                                    #[cfg(feature = "ignore_duplicates")]
1029                                    {
1030                                        __A::skip_value(&mut __map)?;
1031                                        continue;
1032                                    }
1033                                    #[cfg(feature = "strict")]
1034                                    return _serde::__private::Err(
1035                                        <__A::Error as _serde::de::Error>::duplicate_field(
1036                                            "behaviorGraph",
1037                                        ),
1038                                    );
1039                                }
1040                                m_behaviorGraph = _serde::__private::Some(
1041                                    match __A::next_value::<Pointer>(&mut __map) {
1042                                        _serde::__private::Ok(__val) => __val,
1043                                        _serde::__private::Err(__err) => {
1044                                            return _serde::__private::Err(__err);
1045                                        }
1046                                    },
1047                                );
1048                            }
1049                            __Field::m_projectData => {
1050                                #[cfg(
1051                                    any(feature = "strict", feature = "ignore_duplicates")
1052                                )]
1053                                if _serde::__private::Option::is_some(&m_projectData) {
1054                                    #[cfg(feature = "ignore_duplicates")]
1055                                    {
1056                                        __A::skip_value(&mut __map)?;
1057                                        continue;
1058                                    }
1059                                    #[cfg(feature = "strict")]
1060                                    return _serde::__private::Err(
1061                                        <__A::Error as _serde::de::Error>::duplicate_field(
1062                                            "projectData",
1063                                        ),
1064                                    );
1065                                }
1066                                m_projectData = _serde::__private::Some(
1067                                    match __A::next_value::<Pointer>(&mut __map) {
1068                                        _serde::__private::Ok(__val) => __val,
1069                                        _serde::__private::Err(__err) => {
1070                                            return _serde::__private::Err(__err);
1071                                        }
1072                                    },
1073                                );
1074                            }
1075                            _ => __A::skip_value(&mut __map)?,
1076                        }
1077                    }
1078                    let m_nearbyCharacters = match m_nearbyCharacters {
1079                        _serde::__private::Some(__field) => __field,
1080                        _serde::__private::None => {
1081                            #[cfg(feature = "strict")]
1082                            return _serde::__private::Err(
1083                                <__A::Error as _serde::de::Error>::missing_field(
1084                                    "nearbyCharacters",
1085                                ),
1086                            );
1087                            #[cfg(not(feature = "strict"))] Default::default()
1088                        }
1089                    };
1090                    let m_currentLod = match m_currentLod {
1091                        _serde::__private::Some(__field) => __field,
1092                        _serde::__private::None => {
1093                            #[cfg(feature = "strict")]
1094                            return _serde::__private::Err(
1095                                <__A::Error as _serde::de::Error>::missing_field(
1096                                    "currentLod",
1097                                ),
1098                            );
1099                            #[cfg(not(feature = "strict"))] Default::default()
1100                        }
1101                    };
1102                    let m_name = match m_name {
1103                        _serde::__private::Some(__field) => __field,
1104                        _serde::__private::None => {
1105                            #[cfg(feature = "strict")]
1106                            return _serde::__private::Err(
1107                                <__A::Error as _serde::de::Error>::missing_field("name"),
1108                            );
1109                            #[cfg(not(feature = "strict"))] Default::default()
1110                        }
1111                    };
1112                    let m_setup = match m_setup {
1113                        _serde::__private::Some(__field) => __field,
1114                        _serde::__private::None => {
1115                            #[cfg(feature = "strict")]
1116                            return _serde::__private::Err(
1117                                <__A::Error as _serde::de::Error>::missing_field("setup"),
1118                            );
1119                            #[cfg(not(feature = "strict"))] Default::default()
1120                        }
1121                    };
1122                    let m_behaviorGraph = match m_behaviorGraph {
1123                        _serde::__private::Some(__field) => __field,
1124                        _serde::__private::None => {
1125                            #[cfg(feature = "strict")]
1126                            return _serde::__private::Err(
1127                                <__A::Error as _serde::de::Error>::missing_field(
1128                                    "behaviorGraph",
1129                                ),
1130                            );
1131                            #[cfg(not(feature = "strict"))] Default::default()
1132                        }
1133                    };
1134                    let m_projectData = match m_projectData {
1135                        _serde::__private::Some(__field) => __field,
1136                        _serde::__private::None => {
1137                            #[cfg(feature = "strict")]
1138                            return _serde::__private::Err(
1139                                <__A::Error as _serde::de::Error>::missing_field(
1140                                    "projectData",
1141                                ),
1142                            );
1143                            #[cfg(not(feature = "strict"))] Default::default()
1144                        }
1145                    };
1146                    let __ptr = None;
1147                    let parent = hkBaseObject { __ptr };
1148                    let parent = hkReferencedObject {
1149                        __ptr,
1150                        parent,
1151                        ..Default::default()
1152                    };
1153                    let __ptr = __A::class_ptr(&mut __map);
1154                    _serde::__private::Ok(hkbCharacter {
1155                        __ptr,
1156                        parent,
1157                        m_nearbyCharacters,
1158                        m_currentLod,
1159                        m_name,
1160                        m_setup,
1161                        m_behaviorGraph,
1162                        m_projectData,
1163                        ..Default::default()
1164                    })
1165                }
1166            }
1167            const FIELDS: &[&str] = &[
1168                "nearbyCharacters",
1169                "currentLod",
1170                "numTracksInLod",
1171                "name",
1172                "ragdollDriver",
1173                "characterControllerDriver",
1174                "footIkDriver",
1175                "handIkDriver",
1176                "setup",
1177                "behaviorGraph",
1178                "projectData",
1179                "animationBindingSet",
1180                "raycastInterface",
1181                "world",
1182                "eventQueue",
1183                "worldFromModel",
1184                "poseLocal",
1185                "deleteWorldFromModel",
1186                "deletePoseLocal",
1187            ];
1188            _serde::Deserializer::deserialize_struct(
1189                deserializer,
1190                "hkbCharacter",
1191                FIELDS,
1192                __hkbCharacterVisitor {
1193                    marker: _serde::__private::PhantomData::<hkbCharacter>,
1194                    lifetime: _serde::__private::PhantomData,
1195                },
1196            )
1197        }
1198    }
1199};
havok_classes/generated/hkbCharacter_.rs

havok_classes/generated/
hkbCharacter_.rs
