havok_classes/generated/
hkbContext_.rs

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

havok_classes/generated/
hkbContext_.rs
