havok_classes/generated/
hkbBehaviorGraph_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbBehaviorGraph`
5/// - version: `1`
6/// - signature: `0xb1218f86`
7/// - size: `176`(x86)/`304`(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 hkbBehaviorGraph<'a> {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkbGenerator<'a>,
31    /// # C++ Info
32    /// - name: `variableMode`(ctype: `enum VariableMode`)
33    /// - offset: ` 40`(x86)/` 72`(x86_64)
34    /// - type_size: `  1`(x86)/`  1`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "variableMode"))]
36    #[cfg_attr(feature = "serde", serde(rename = "variableMode"))]
37    pub m_variableMode: VariableMode,
38    /// # C++ Info
39    /// - name: `uniqueIdPool`(ctype: `hkArray<void>`)
40    /// - offset: ` 44`(x86)/` 80`(x86_64)
41    /// - type_size: ` 12`(x86)/` 16`(x86_64)
42    /// - flags: `SERIALIZE_IGNORED`
43    #[cfg_attr(feature = "json_schema", schemars(rename = "uniqueIdPool"))]
44    #[cfg_attr(feature = "serde", serde(rename = "uniqueIdPool"))]
45    pub m_uniqueIdPool: Vec<()>,
46    /// # C++ Info
47    /// - name: `idToStateMachineTemplateMap`(ctype: `void*`)
48    /// - offset: ` 56`(x86)/` 96`(x86_64)
49    /// - type_size: `  4`(x86)/`  8`(x86_64)
50    /// - flags: `SERIALIZE_IGNORED`
51    #[cfg_attr(
52        feature = "json_schema",
53        schemars(rename = "idToStateMachineTemplateMap")
54    )]
55    #[cfg_attr(feature = "serde", serde(rename = "idToStateMachineTemplateMap"))]
56    pub m_idToStateMachineTemplateMap: Pointer,
57    /// # C++ Info
58    /// - name: `mirroredExternalIdMap`(ctype: `hkArray<void>`)
59    /// - offset: ` 60`(x86)/`104`(x86_64)
60    /// - type_size: ` 12`(x86)/` 16`(x86_64)
61    /// - flags: `SERIALIZE_IGNORED`
62    #[cfg_attr(feature = "json_schema", schemars(rename = "mirroredExternalIdMap"))]
63    #[cfg_attr(feature = "serde", serde(rename = "mirroredExternalIdMap"))]
64    pub m_mirroredExternalIdMap: Vec<()>,
65    /// # C++ Info
66    /// - name: `pseudoRandomGenerator`(ctype: `void*`)
67    /// - offset: ` 72`(x86)/`120`(x86_64)
68    /// - type_size: `  4`(x86)/`  8`(x86_64)
69    /// - flags: `SERIALIZE_IGNORED`
70    #[cfg_attr(feature = "json_schema", schemars(rename = "pseudoRandomGenerator"))]
71    #[cfg_attr(feature = "serde", serde(rename = "pseudoRandomGenerator"))]
72    pub m_pseudoRandomGenerator: Pointer,
73    /// # C++ Info
74    /// - name: `rootGenerator`(ctype: `struct hkbGenerator*`)
75    /// - offset: ` 76`(x86)/`128`(x86_64)
76    /// - type_size: `  4`(x86)/`  8`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "rootGenerator"))]
78    #[cfg_attr(feature = "serde", serde(rename = "rootGenerator"))]
79    pub m_rootGenerator: Pointer,
80    /// # C++ Info
81    /// - name: `data`(ctype: `struct hkbBehaviorGraphData*`)
82    /// - offset: ` 80`(x86)/`136`(x86_64)
83    /// - type_size: `  4`(x86)/`  8`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
85    #[cfg_attr(feature = "serde", serde(rename = "data"))]
86    pub m_data: Pointer,
87    /// # C++ Info
88    /// - name: `rootGeneratorClone`(ctype: `void*`)
89    /// - offset: ` 84`(x86)/`144`(x86_64)
90    /// - type_size: `  4`(x86)/`  8`(x86_64)
91    /// - flags: `SERIALIZE_IGNORED`
92    #[cfg_attr(feature = "json_schema", schemars(rename = "rootGeneratorClone"))]
93    #[cfg_attr(feature = "serde", serde(rename = "rootGeneratorClone"))]
94    pub m_rootGeneratorClone: Pointer,
95    /// # C++ Info
96    /// - name: `activeNodes`(ctype: `void*`)
97    /// - offset: ` 88`(x86)/`152`(x86_64)
98    /// - type_size: `  4`(x86)/`  8`(x86_64)
99    /// - flags: `SERIALIZE_IGNORED`
100    #[cfg_attr(feature = "json_schema", schemars(rename = "activeNodes"))]
101    #[cfg_attr(feature = "serde", serde(rename = "activeNodes"))]
102    pub m_activeNodes: Pointer,
103    /// # C++ Info
104    /// - name: `activeNodeTemplateToIndexMap`(ctype: `void*`)
105    /// - offset: ` 92`(x86)/`160`(x86_64)
106    /// - type_size: `  4`(x86)/`  8`(x86_64)
107    /// - flags: `SERIALIZE_IGNORED`
108    #[cfg_attr(
109        feature = "json_schema",
110        schemars(rename = "activeNodeTemplateToIndexMap")
111    )]
112    #[cfg_attr(feature = "serde", serde(rename = "activeNodeTemplateToIndexMap"))]
113    pub m_activeNodeTemplateToIndexMap: Pointer,
114    /// # C++ Info
115    /// - name: `activeNodesChildrenIndices`(ctype: `void*`)
116    /// - offset: ` 96`(x86)/`168`(x86_64)
117    /// - type_size: `  4`(x86)/`  8`(x86_64)
118    /// - flags: `SERIALIZE_IGNORED`
119    #[cfg_attr(feature = "json_schema", schemars(rename = "activeNodesChildrenIndices"))]
120    #[cfg_attr(feature = "serde", serde(rename = "activeNodesChildrenIndices"))]
121    pub m_activeNodesChildrenIndices: Pointer,
122    /// # C++ Info
123    /// - name: `globalTransitionData`(ctype: `void*`)
124    /// - offset: `100`(x86)/`176`(x86_64)
125    /// - type_size: `  4`(x86)/`  8`(x86_64)
126    /// - flags: `SERIALIZE_IGNORED`
127    #[cfg_attr(feature = "json_schema", schemars(rename = "globalTransitionData"))]
128    #[cfg_attr(feature = "serde", serde(rename = "globalTransitionData"))]
129    pub m_globalTransitionData: Pointer,
130    /// # C++ Info
131    /// - name: `eventIdMap`(ctype: `void*`)
132    /// - offset: `104`(x86)/`184`(x86_64)
133    /// - type_size: `  4`(x86)/`  8`(x86_64)
134    /// - flags: `SERIALIZE_IGNORED`
135    #[cfg_attr(feature = "json_schema", schemars(rename = "eventIdMap"))]
136    #[cfg_attr(feature = "serde", serde(rename = "eventIdMap"))]
137    pub m_eventIdMap: Pointer,
138    /// # C++ Info
139    /// - name: `attributeIdMap`(ctype: `void*`)
140    /// - offset: `108`(x86)/`192`(x86_64)
141    /// - type_size: `  4`(x86)/`  8`(x86_64)
142    /// - flags: `SERIALIZE_IGNORED`
143    #[cfg_attr(feature = "json_schema", schemars(rename = "attributeIdMap"))]
144    #[cfg_attr(feature = "serde", serde(rename = "attributeIdMap"))]
145    pub m_attributeIdMap: Pointer,
146    /// # C++ Info
147    /// - name: `variableIdMap`(ctype: `void*`)
148    /// - offset: `112`(x86)/`200`(x86_64)
149    /// - type_size: `  4`(x86)/`  8`(x86_64)
150    /// - flags: `SERIALIZE_IGNORED`
151    #[cfg_attr(feature = "json_schema", schemars(rename = "variableIdMap"))]
152    #[cfg_attr(feature = "serde", serde(rename = "variableIdMap"))]
153    pub m_variableIdMap: Pointer,
154    /// # C++ Info
155    /// - name: `characterPropertyIdMap`(ctype: `void*`)
156    /// - offset: `116`(x86)/`208`(x86_64)
157    /// - type_size: `  4`(x86)/`  8`(x86_64)
158    /// - flags: `SERIALIZE_IGNORED`
159    #[cfg_attr(feature = "json_schema", schemars(rename = "characterPropertyIdMap"))]
160    #[cfg_attr(feature = "serde", serde(rename = "characterPropertyIdMap"))]
161    pub m_characterPropertyIdMap: Pointer,
162    /// # C++ Info
163    /// - name: `variableValueSet`(ctype: `void*`)
164    /// - offset: `120`(x86)/`216`(x86_64)
165    /// - type_size: `  4`(x86)/`  8`(x86_64)
166    /// - flags: `SERIALIZE_IGNORED`
167    #[cfg_attr(feature = "json_schema", schemars(rename = "variableValueSet"))]
168    #[cfg_attr(feature = "serde", serde(rename = "variableValueSet"))]
169    pub m_variableValueSet: Pointer,
170    /// # C++ Info
171    /// - name: `nodeTemplateToCloneMap`(ctype: `void*`)
172    /// - offset: `124`(x86)/`224`(x86_64)
173    /// - type_size: `  4`(x86)/`  8`(x86_64)
174    /// - flags: `SERIALIZE_IGNORED`
175    #[cfg_attr(feature = "json_schema", schemars(rename = "nodeTemplateToCloneMap"))]
176    #[cfg_attr(feature = "serde", serde(rename = "nodeTemplateToCloneMap"))]
177    pub m_nodeTemplateToCloneMap: Pointer,
178    /// # C++ Info
179    /// - name: `nodeCloneToTemplateMap`(ctype: `void*`)
180    /// - offset: `128`(x86)/`232`(x86_64)
181    /// - type_size: `  4`(x86)/`  8`(x86_64)
182    /// - flags: `SERIALIZE_IGNORED`
183    #[cfg_attr(feature = "json_schema", schemars(rename = "nodeCloneToTemplateMap"))]
184    #[cfg_attr(feature = "serde", serde(rename = "nodeCloneToTemplateMap"))]
185    pub m_nodeCloneToTemplateMap: Pointer,
186    /// # C++ Info
187    /// - name: `stateListenerTemplateToCloneMap`(ctype: `void*`)
188    /// - offset: `132`(x86)/`240`(x86_64)
189    /// - type_size: `  4`(x86)/`  8`(x86_64)
190    /// - flags: `SERIALIZE_IGNORED`
191    #[cfg_attr(
192        feature = "json_schema",
193        schemars(rename = "stateListenerTemplateToCloneMap")
194    )]
195    #[cfg_attr(feature = "serde", serde(rename = "stateListenerTemplateToCloneMap"))]
196    pub m_stateListenerTemplateToCloneMap: Pointer,
197    /// # C++ Info
198    /// - name: `nodePartitionInfo`(ctype: `void*`)
199    /// - offset: `136`(x86)/`248`(x86_64)
200    /// - type_size: `  4`(x86)/`  8`(x86_64)
201    /// - flags: `SERIALIZE_IGNORED`
202    #[cfg_attr(feature = "json_schema", schemars(rename = "nodePartitionInfo"))]
203    #[cfg_attr(feature = "serde", serde(rename = "nodePartitionInfo"))]
204    pub m_nodePartitionInfo: Pointer,
205    /// # C++ Info
206    /// - name: `numIntermediateOutputs`(ctype: `hkInt32`)
207    /// - offset: `140`(x86)/`256`(x86_64)
208    /// - type_size: `  4`(x86)/`  4`(x86_64)
209    /// - flags: `SERIALIZE_IGNORED`
210    #[cfg_attr(feature = "json_schema", schemars(rename = "numIntermediateOutputs"))]
211    #[cfg_attr(feature = "serde", serde(rename = "numIntermediateOutputs"))]
212    pub m_numIntermediateOutputs: i32,
213    /// # C++ Info
214    /// - name: `jobs`(ctype: `hkArray<void*>`)
215    /// - offset: `144`(x86)/`264`(x86_64)
216    /// - type_size: ` 12`(x86)/` 16`(x86_64)
217    /// - flags: `SERIALIZE_IGNORED`
218    #[cfg_attr(feature = "json_schema", schemars(rename = "jobs"))]
219    #[cfg_attr(feature = "serde", serde(rename = "jobs"))]
220    pub m_jobs: Vec<Pointer>,
221    /// # C++ Info
222    /// - name: `allPartitionMemory`(ctype: `hkArray<void*>`)
223    /// - offset: `156`(x86)/`280`(x86_64)
224    /// - type_size: ` 12`(x86)/` 16`(x86_64)
225    /// - flags: `SERIALIZE_IGNORED`
226    #[cfg_attr(feature = "json_schema", schemars(rename = "allPartitionMemory"))]
227    #[cfg_attr(feature = "serde", serde(rename = "allPartitionMemory"))]
228    pub m_allPartitionMemory: Vec<Pointer>,
229    /// # C++ Info
230    /// - name: `numStaticNodes`(ctype: `hkInt16`)
231    /// - offset: `168`(x86)/`296`(x86_64)
232    /// - type_size: `  2`(x86)/`  2`(x86_64)
233    /// - flags: `SERIALIZE_IGNORED`
234    #[cfg_attr(feature = "json_schema", schemars(rename = "numStaticNodes"))]
235    #[cfg_attr(feature = "serde", serde(rename = "numStaticNodes"))]
236    pub m_numStaticNodes: i16,
237    /// # C++ Info
238    /// - name: `nextUniqueId`(ctype: `hkInt16`)
239    /// - offset: `170`(x86)/`298`(x86_64)
240    /// - type_size: `  2`(x86)/`  2`(x86_64)
241    /// - flags: `SERIALIZE_IGNORED`
242    #[cfg_attr(feature = "json_schema", schemars(rename = "nextUniqueId"))]
243    #[cfg_attr(feature = "serde", serde(rename = "nextUniqueId"))]
244    pub m_nextUniqueId: i16,
245    /// # C++ Info
246    /// - name: `isActive`(ctype: `hkBool`)
247    /// - offset: `172`(x86)/`300`(x86_64)
248    /// - type_size: `  1`(x86)/`  1`(x86_64)
249    /// - flags: `SERIALIZE_IGNORED`
250    #[cfg_attr(feature = "json_schema", schemars(rename = "isActive"))]
251    #[cfg_attr(feature = "serde", serde(rename = "isActive"))]
252    pub m_isActive: bool,
253    /// # C++ Info
254    /// - name: `isLinked`(ctype: `hkBool`)
255    /// - offset: `173`(x86)/`301`(x86_64)
256    /// - type_size: `  1`(x86)/`  1`(x86_64)
257    /// - flags: `SERIALIZE_IGNORED`
258    #[cfg_attr(feature = "json_schema", schemars(rename = "isLinked"))]
259    #[cfg_attr(feature = "serde", serde(rename = "isLinked"))]
260    pub m_isLinked: bool,
261    /// # C++ Info
262    /// - name: `updateActiveNodes`(ctype: `hkBool`)
263    /// - offset: `174`(x86)/`302`(x86_64)
264    /// - type_size: `  1`(x86)/`  1`(x86_64)
265    /// - flags: `SERIALIZE_IGNORED`
266    #[cfg_attr(feature = "json_schema", schemars(rename = "updateActiveNodes"))]
267    #[cfg_attr(feature = "serde", serde(rename = "updateActiveNodes"))]
268    pub m_updateActiveNodes: bool,
269    /// # C++ Info
270    /// - name: `stateOrTransitionChanged`(ctype: `hkBool`)
271    /// - offset: `175`(x86)/`303`(x86_64)
272    /// - type_size: `  1`(x86)/`  1`(x86_64)
273    /// - flags: `SERIALIZE_IGNORED`
274    #[cfg_attr(feature = "json_schema", schemars(rename = "stateOrTransitionChanged"))]
275    #[cfg_attr(feature = "serde", serde(rename = "stateOrTransitionChanged"))]
276    pub m_stateOrTransitionChanged: bool,
277}
278const _: () = {
279    use havok_serde as _serde;
280    impl<'a> _serde::HavokClass for hkbBehaviorGraph<'a> {
281        #[inline]
282        fn name(&self) -> &'static str {
283            "hkbBehaviorGraph"
284        }
285        #[inline]
286        fn signature(&self) -> _serde::__private::Signature {
287            _serde::__private::Signature::new(0xb1218f86)
288        }
289        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
290        fn deps_indexes(&self) -> Vec<usize> {
291            let mut v = Vec::new();
292            v.push(self.parent.parent.parent.m_variableBindingSet.get());
293            v.push(self.m_idToStateMachineTemplateMap.get());
294            v.push(self.m_pseudoRandomGenerator.get());
295            v.push(self.m_rootGenerator.get());
296            v.push(self.m_data.get());
297            v.push(self.m_rootGeneratorClone.get());
298            v.push(self.m_activeNodes.get());
299            v.push(self.m_activeNodeTemplateToIndexMap.get());
300            v.push(self.m_activeNodesChildrenIndices.get());
301            v.push(self.m_globalTransitionData.get());
302            v.push(self.m_eventIdMap.get());
303            v.push(self.m_attributeIdMap.get());
304            v.push(self.m_variableIdMap.get());
305            v.push(self.m_characterPropertyIdMap.get());
306            v.push(self.m_variableValueSet.get());
307            v.push(self.m_nodeTemplateToCloneMap.get());
308            v.push(self.m_nodeCloneToTemplateMap.get());
309            v.push(self.m_stateListenerTemplateToCloneMap.get());
310            v.push(self.m_nodePartitionInfo.get());
311            v.extend(self.m_jobs.iter().map(|ptr| ptr.get()));
312            v.extend(self.m_allPartitionMemory.iter().map(|ptr| ptr.get()));
313            v
314        }
315    }
316    impl<'a> _serde::Serialize for hkbBehaviorGraph<'a> {
317        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
318        where
319            S: _serde::ser::Serializer,
320        {
321            let class_meta = self
322                .__ptr
323                .map(|name| (name, _serde::__private::Signature::new(0xb1218f86)));
324            let mut serializer = __serializer
325                .serialize_struct("hkbBehaviorGraph", class_meta, (176u64, 304u64))?;
326            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
327            serializer
328                .skip_field(
329                    "memSizeAndFlags",
330                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
331                )?;
332            serializer
333                .skip_field(
334                    "referenceCount",
335                    &self.parent.parent.parent.parent.m_referenceCount,
336                )?;
337            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
338            serializer
339                .serialize_field(
340                    "variableBindingSet",
341                    &self.parent.parent.parent.m_variableBindingSet,
342                )?;
343            serializer
344                .skip_array_field(
345                    "cachedBindables",
346                    &self.parent.parent.parent.m_cachedBindables,
347                    TypeSize::NonPtr,
348                )?;
349            serializer
350                .skip_field(
351                    "areBindablesCached",
352                    &self.parent.parent.parent.m_areBindablesCached,
353                )?;
354            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
355            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
356            serializer.serialize_field("name", &self.parent.parent.m_name)?;
357            serializer.skip_field("id", &self.parent.parent.m_id)?;
358            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
359            serializer
360                .skip_fixed_array_field(
361                    "padNode",
362                    self.parent.parent.m_padNode.as_slice(),
363                    TypeSize::NonPtr,
364                )?;
365            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
366            serializer.serialize_field("variableMode", &self.m_variableMode)?;
367            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
368            serializer
369                .skip_array_field(
370                    "uniqueIdPool",
371                    &self.m_uniqueIdPool,
372                    TypeSize::NonPtr,
373                )?;
374            serializer
375                .skip_field(
376                    "idToStateMachineTemplateMap",
377                    &self.m_idToStateMachineTemplateMap,
378                )?;
379            serializer
380                .skip_array_field(
381                    "mirroredExternalIdMap",
382                    &self.m_mirroredExternalIdMap,
383                    TypeSize::NonPtr,
384                )?;
385            serializer
386                .skip_field("pseudoRandomGenerator", &self.m_pseudoRandomGenerator)?;
387            serializer.serialize_field("rootGenerator", &self.m_rootGenerator)?;
388            serializer.serialize_field("data", &self.m_data)?;
389            serializer.skip_field("rootGeneratorClone", &self.m_rootGeneratorClone)?;
390            serializer.skip_field("activeNodes", &self.m_activeNodes)?;
391            serializer
392                .skip_field(
393                    "activeNodeTemplateToIndexMap",
394                    &self.m_activeNodeTemplateToIndexMap,
395                )?;
396            serializer
397                .skip_field(
398                    "activeNodesChildrenIndices",
399                    &self.m_activeNodesChildrenIndices,
400                )?;
401            serializer.skip_field("globalTransitionData", &self.m_globalTransitionData)?;
402            serializer.skip_field("eventIdMap", &self.m_eventIdMap)?;
403            serializer.skip_field("attributeIdMap", &self.m_attributeIdMap)?;
404            serializer.skip_field("variableIdMap", &self.m_variableIdMap)?;
405            serializer
406                .skip_field("characterPropertyIdMap", &self.m_characterPropertyIdMap)?;
407            serializer.skip_field("variableValueSet", &self.m_variableValueSet)?;
408            serializer
409                .skip_field("nodeTemplateToCloneMap", &self.m_nodeTemplateToCloneMap)?;
410            serializer
411                .skip_field("nodeCloneToTemplateMap", &self.m_nodeCloneToTemplateMap)?;
412            serializer
413                .skip_field(
414                    "stateListenerTemplateToCloneMap",
415                    &self.m_stateListenerTemplateToCloneMap,
416                )?;
417            serializer.skip_field("nodePartitionInfo", &self.m_nodePartitionInfo)?;
418            serializer
419                .skip_field("numIntermediateOutputs", &self.m_numIntermediateOutputs)?;
420            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
421            serializer.skip_array_field("jobs", &self.m_jobs, TypeSize::NonPtr)?;
422            serializer
423                .skip_array_field(
424                    "allPartitionMemory",
425                    &self.m_allPartitionMemory,
426                    TypeSize::NonPtr,
427                )?;
428            serializer.skip_field("numStaticNodes", &self.m_numStaticNodes)?;
429            serializer.skip_field("nextUniqueId", &self.m_nextUniqueId)?;
430            serializer.skip_field("isActive", &self.m_isActive)?;
431            serializer.skip_field("isLinked", &self.m_isLinked)?;
432            serializer.skip_field("updateActiveNodes", &self.m_updateActiveNodes)?;
433            serializer
434                .skip_field(
435                    "stateOrTransitionChanged",
436                    &self.m_stateOrTransitionChanged,
437                )?;
438            serializer.end()
439        }
440    }
441};
442#[doc(hidden)]
443#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
444const _: () = {
445    use havok_serde as _serde;
446    #[automatically_derived]
447    impl<'de> _serde::Deserialize<'de> for hkbBehaviorGraph<'de> {
448        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
449        where
450            __D: _serde::Deserializer<'de>,
451        {
452            #[allow(non_camel_case_types)]
453            enum __Field {
454                m_variableBindingSet,
455                m_userData,
456                m_name,
457                m_variableMode,
458                m_rootGenerator,
459                m_data,
460                __ignore,
461            }
462            struct __FieldVisitor;
463            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
464                type Value = __Field;
465                fn expecting(
466                    &self,
467                    __formatter: &mut core::fmt::Formatter,
468                ) -> core::fmt::Result {
469                    core::fmt::Formatter::write_str(__formatter, "field identifier")
470                }
471                /// Intended for use in XML.
472                #[allow(clippy::match_single_binding)]
473                #[allow(clippy::reversed_empty_ranges)]
474                #[allow(clippy::single_match)]
475                fn visit_key<__E>(
476                    self,
477                    __value: &str,
478                ) -> core::result::Result<Self::Value, __E>
479                where
480                    __E: _serde::de::Error,
481                {
482                    match __value {
483                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
484                        "userData" => Ok(__Field::m_userData),
485                        "name" => Ok(__Field::m_name),
486                        "variableMode" => Ok(__Field::m_variableMode),
487                        "rootGenerator" => Ok(__Field::m_rootGenerator),
488                        "data" => Ok(__Field::m_data),
489                        _ => Ok(__Field::__ignore),
490                    }
491                }
492            }
493            impl<'de> _serde::Deserialize<'de> for __Field {
494                #[inline]
495                fn deserialize<__D>(
496                    __deserializer: __D,
497                ) -> core::result::Result<Self, __D::Error>
498                where
499                    __D: _serde::Deserializer<'de>,
500                {
501                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
502                }
503            }
504            struct __hkbBehaviorGraphVisitor<'de> {
505                marker: _serde::__private::PhantomData<hkbBehaviorGraph<'de>>,
506                lifetime: _serde::__private::PhantomData<&'de ()>,
507            }
508            #[allow(clippy::match_single_binding)]
509            #[allow(clippy::reversed_empty_ranges)]
510            #[allow(clippy::single_match)]
511            impl<'de> _serde::de::Visitor<'de> for __hkbBehaviorGraphVisitor<'de> {
512                type Value = hkbBehaviorGraph<'de>;
513                fn expecting(
514                    &self,
515                    __formatter: &mut core::fmt::Formatter,
516                ) -> core::fmt::Result {
517                    core::fmt::Formatter::write_str(
518                        __formatter,
519                        "struct hkbBehaviorGraph",
520                    )
521                }
522                fn visit_struct_for_bytes<__A>(
523                    self,
524                    mut __map: __A,
525                ) -> _serde::__private::Result<Self::Value, __A::Error>
526                where
527                    __A: _serde::de::MapAccess<'de>,
528                {
529                    let __ptr = __A::class_ptr(&mut __map);
530                    let parent = __A::parent_value(&mut __map)?;
531                    let mut m_variableMode: _serde::__private::Option<VariableMode> = _serde::__private::None;
532                    let mut m_uniqueIdPool: _serde::__private::Option<Vec<()>> = _serde::__private::None;
533                    let mut m_idToStateMachineTemplateMap: _serde::__private::Option<
534                        Pointer,
535                    > = _serde::__private::None;
536                    let mut m_mirroredExternalIdMap: _serde::__private::Option<
537                        Vec<()>,
538                    > = _serde::__private::None;
539                    let mut m_pseudoRandomGenerator: _serde::__private::Option<
540                        Pointer,
541                    > = _serde::__private::None;
542                    let mut m_rootGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
543                    let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
544                    let mut m_rootGeneratorClone: _serde::__private::Option<Pointer> = _serde::__private::None;
545                    let mut m_activeNodes: _serde::__private::Option<Pointer> = _serde::__private::None;
546                    let mut m_activeNodeTemplateToIndexMap: _serde::__private::Option<
547                        Pointer,
548                    > = _serde::__private::None;
549                    let mut m_activeNodesChildrenIndices: _serde::__private::Option<
550                        Pointer,
551                    > = _serde::__private::None;
552                    let mut m_globalTransitionData: _serde::__private::Option<Pointer> = _serde::__private::None;
553                    let mut m_eventIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
554                    let mut m_attributeIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
555                    let mut m_variableIdMap: _serde::__private::Option<Pointer> = _serde::__private::None;
556                    let mut m_characterPropertyIdMap: _serde::__private::Option<
557                        Pointer,
558                    > = _serde::__private::None;
559                    let mut m_variableValueSet: _serde::__private::Option<Pointer> = _serde::__private::None;
560                    let mut m_nodeTemplateToCloneMap: _serde::__private::Option<
561                        Pointer,
562                    > = _serde::__private::None;
563                    let mut m_nodeCloneToTemplateMap: _serde::__private::Option<
564                        Pointer,
565                    > = _serde::__private::None;
566                    let mut m_stateListenerTemplateToCloneMap: _serde::__private::Option<
567                        Pointer,
568                    > = _serde::__private::None;
569                    let mut m_nodePartitionInfo: _serde::__private::Option<Pointer> = _serde::__private::None;
570                    let mut m_numIntermediateOutputs: _serde::__private::Option<i32> = _serde::__private::None;
571                    let mut m_jobs: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
572                    let mut m_allPartitionMemory: _serde::__private::Option<
573                        Vec<Pointer>,
574                    > = _serde::__private::None;
575                    let mut m_numStaticNodes: _serde::__private::Option<i16> = _serde::__private::None;
576                    let mut m_nextUniqueId: _serde::__private::Option<i16> = _serde::__private::None;
577                    let mut m_isActive: _serde::__private::Option<bool> = _serde::__private::None;
578                    let mut m_isLinked: _serde::__private::Option<bool> = _serde::__private::None;
579                    let mut m_updateActiveNodes: _serde::__private::Option<bool> = _serde::__private::None;
580                    let mut m_stateOrTransitionChanged: _serde::__private::Option<
581                        bool,
582                    > = _serde::__private::None;
583                    for i in 0..30usize {
584                        match i {
585                            0usize => {
586                                if _serde::__private::Option::is_some(&m_variableMode) {
587                                    return _serde::__private::Err(
588                                        <__A::Error as _serde::de::Error>::duplicate_field(
589                                            "variableMode",
590                                        ),
591                                    );
592                                }
593                                m_variableMode = _serde::__private::Some(
594                                    match __A::next_value::<VariableMode>(&mut __map) {
595                                        _serde::__private::Ok(__val) => __val,
596                                        _serde::__private::Err(__err) => {
597                                            return _serde::__private::Err(__err);
598                                        }
599                                    },
600                                );
601                            }
602                            1usize => {
603                                if _serde::__private::Option::is_some(&m_uniqueIdPool) {
604                                    return _serde::__private::Err(
605                                        <__A::Error as _serde::de::Error>::duplicate_field(
606                                            "uniqueIdPool",
607                                        ),
608                                    );
609                                }
610                                __A::pad(&mut __map, 3usize, 7usize)?;
611                                m_uniqueIdPool = _serde::__private::Some(
612                                    match __A::next_value::<Vec<()>>(&mut __map) {
613                                        _serde::__private::Ok(__val) => __val,
614                                        _serde::__private::Err(__err) => {
615                                            return _serde::__private::Err(__err);
616                                        }
617                                    },
618                                );
619                            }
620                            2usize => {
621                                if _serde::__private::Option::is_some(
622                                    &m_idToStateMachineTemplateMap,
623                                ) {
624                                    return _serde::__private::Err(
625                                        <__A::Error as _serde::de::Error>::duplicate_field(
626                                            "idToStateMachineTemplateMap",
627                                        ),
628                                    );
629                                }
630                                m_idToStateMachineTemplateMap = _serde::__private::Some(
631                                    match __A::next_value::<Pointer>(&mut __map) {
632                                        _serde::__private::Ok(__val) => __val,
633                                        _serde::__private::Err(__err) => {
634                                            return _serde::__private::Err(__err);
635                                        }
636                                    },
637                                );
638                            }
639                            3usize => {
640                                if _serde::__private::Option::is_some(
641                                    &m_mirroredExternalIdMap,
642                                ) {
643                                    return _serde::__private::Err(
644                                        <__A::Error as _serde::de::Error>::duplicate_field(
645                                            "mirroredExternalIdMap",
646                                        ),
647                                    );
648                                }
649                                m_mirroredExternalIdMap = _serde::__private::Some(
650                                    match __A::next_value::<Vec<()>>(&mut __map) {
651                                        _serde::__private::Ok(__val) => __val,
652                                        _serde::__private::Err(__err) => {
653                                            return _serde::__private::Err(__err);
654                                        }
655                                    },
656                                );
657                            }
658                            4usize => {
659                                if _serde::__private::Option::is_some(
660                                    &m_pseudoRandomGenerator,
661                                ) {
662                                    return _serde::__private::Err(
663                                        <__A::Error as _serde::de::Error>::duplicate_field(
664                                            "pseudoRandomGenerator",
665                                        ),
666                                    );
667                                }
668                                m_pseudoRandomGenerator = _serde::__private::Some(
669                                    match __A::next_value::<Pointer>(&mut __map) {
670                                        _serde::__private::Ok(__val) => __val,
671                                        _serde::__private::Err(__err) => {
672                                            return _serde::__private::Err(__err);
673                                        }
674                                    },
675                                );
676                            }
677                            5usize => {
678                                if _serde::__private::Option::is_some(&m_rootGenerator) {
679                                    return _serde::__private::Err(
680                                        <__A::Error as _serde::de::Error>::duplicate_field(
681                                            "rootGenerator",
682                                        ),
683                                    );
684                                }
685                                m_rootGenerator = _serde::__private::Some(
686                                    match __A::next_value::<Pointer>(&mut __map) {
687                                        _serde::__private::Ok(__val) => __val,
688                                        _serde::__private::Err(__err) => {
689                                            return _serde::__private::Err(__err);
690                                        }
691                                    },
692                                );
693                            }
694                            6usize => {
695                                if _serde::__private::Option::is_some(&m_data) {
696                                    return _serde::__private::Err(
697                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
698                                    );
699                                }
700                                m_data = _serde::__private::Some(
701                                    match __A::next_value::<Pointer>(&mut __map) {
702                                        _serde::__private::Ok(__val) => __val,
703                                        _serde::__private::Err(__err) => {
704                                            return _serde::__private::Err(__err);
705                                        }
706                                    },
707                                );
708                            }
709                            7usize => {
710                                if _serde::__private::Option::is_some(
711                                    &m_rootGeneratorClone,
712                                ) {
713                                    return _serde::__private::Err(
714                                        <__A::Error as _serde::de::Error>::duplicate_field(
715                                            "rootGeneratorClone",
716                                        ),
717                                    );
718                                }
719                                m_rootGeneratorClone = _serde::__private::Some(
720                                    match __A::next_value::<Pointer>(&mut __map) {
721                                        _serde::__private::Ok(__val) => __val,
722                                        _serde::__private::Err(__err) => {
723                                            return _serde::__private::Err(__err);
724                                        }
725                                    },
726                                );
727                            }
728                            8usize => {
729                                if _serde::__private::Option::is_some(&m_activeNodes) {
730                                    return _serde::__private::Err(
731                                        <__A::Error as _serde::de::Error>::duplicate_field(
732                                            "activeNodes",
733                                        ),
734                                    );
735                                }
736                                m_activeNodes = _serde::__private::Some(
737                                    match __A::next_value::<Pointer>(&mut __map) {
738                                        _serde::__private::Ok(__val) => __val,
739                                        _serde::__private::Err(__err) => {
740                                            return _serde::__private::Err(__err);
741                                        }
742                                    },
743                                );
744                            }
745                            9usize => {
746                                if _serde::__private::Option::is_some(
747                                    &m_activeNodeTemplateToIndexMap,
748                                ) {
749                                    return _serde::__private::Err(
750                                        <__A::Error as _serde::de::Error>::duplicate_field(
751                                            "activeNodeTemplateToIndexMap",
752                                        ),
753                                    );
754                                }
755                                m_activeNodeTemplateToIndexMap = _serde::__private::Some(
756                                    match __A::next_value::<Pointer>(&mut __map) {
757                                        _serde::__private::Ok(__val) => __val,
758                                        _serde::__private::Err(__err) => {
759                                            return _serde::__private::Err(__err);
760                                        }
761                                    },
762                                );
763                            }
764                            10usize => {
765                                if _serde::__private::Option::is_some(
766                                    &m_activeNodesChildrenIndices,
767                                ) {
768                                    return _serde::__private::Err(
769                                        <__A::Error as _serde::de::Error>::duplicate_field(
770                                            "activeNodesChildrenIndices",
771                                        ),
772                                    );
773                                }
774                                m_activeNodesChildrenIndices = _serde::__private::Some(
775                                    match __A::next_value::<Pointer>(&mut __map) {
776                                        _serde::__private::Ok(__val) => __val,
777                                        _serde::__private::Err(__err) => {
778                                            return _serde::__private::Err(__err);
779                                        }
780                                    },
781                                );
782                            }
783                            11usize => {
784                                if _serde::__private::Option::is_some(
785                                    &m_globalTransitionData,
786                                ) {
787                                    return _serde::__private::Err(
788                                        <__A::Error as _serde::de::Error>::duplicate_field(
789                                            "globalTransitionData",
790                                        ),
791                                    );
792                                }
793                                m_globalTransitionData = _serde::__private::Some(
794                                    match __A::next_value::<Pointer>(&mut __map) {
795                                        _serde::__private::Ok(__val) => __val,
796                                        _serde::__private::Err(__err) => {
797                                            return _serde::__private::Err(__err);
798                                        }
799                                    },
800                                );
801                            }
802                            12usize => {
803                                if _serde::__private::Option::is_some(&m_eventIdMap) {
804                                    return _serde::__private::Err(
805                                        <__A::Error as _serde::de::Error>::duplicate_field(
806                                            "eventIdMap",
807                                        ),
808                                    );
809                                }
810                                m_eventIdMap = _serde::__private::Some(
811                                    match __A::next_value::<Pointer>(&mut __map) {
812                                        _serde::__private::Ok(__val) => __val,
813                                        _serde::__private::Err(__err) => {
814                                            return _serde::__private::Err(__err);
815                                        }
816                                    },
817                                );
818                            }
819                            13usize => {
820                                if _serde::__private::Option::is_some(&m_attributeIdMap) {
821                                    return _serde::__private::Err(
822                                        <__A::Error as _serde::de::Error>::duplicate_field(
823                                            "attributeIdMap",
824                                        ),
825                                    );
826                                }
827                                m_attributeIdMap = _serde::__private::Some(
828                                    match __A::next_value::<Pointer>(&mut __map) {
829                                        _serde::__private::Ok(__val) => __val,
830                                        _serde::__private::Err(__err) => {
831                                            return _serde::__private::Err(__err);
832                                        }
833                                    },
834                                );
835                            }
836                            14usize => {
837                                if _serde::__private::Option::is_some(&m_variableIdMap) {
838                                    return _serde::__private::Err(
839                                        <__A::Error as _serde::de::Error>::duplicate_field(
840                                            "variableIdMap",
841                                        ),
842                                    );
843                                }
844                                m_variableIdMap = _serde::__private::Some(
845                                    match __A::next_value::<Pointer>(&mut __map) {
846                                        _serde::__private::Ok(__val) => __val,
847                                        _serde::__private::Err(__err) => {
848                                            return _serde::__private::Err(__err);
849                                        }
850                                    },
851                                );
852                            }
853                            15usize => {
854                                if _serde::__private::Option::is_some(
855                                    &m_characterPropertyIdMap,
856                                ) {
857                                    return _serde::__private::Err(
858                                        <__A::Error as _serde::de::Error>::duplicate_field(
859                                            "characterPropertyIdMap",
860                                        ),
861                                    );
862                                }
863                                m_characterPropertyIdMap = _serde::__private::Some(
864                                    match __A::next_value::<Pointer>(&mut __map) {
865                                        _serde::__private::Ok(__val) => __val,
866                                        _serde::__private::Err(__err) => {
867                                            return _serde::__private::Err(__err);
868                                        }
869                                    },
870                                );
871                            }
872                            16usize => {
873                                if _serde::__private::Option::is_some(&m_variableValueSet) {
874                                    return _serde::__private::Err(
875                                        <__A::Error as _serde::de::Error>::duplicate_field(
876                                            "variableValueSet",
877                                        ),
878                                    );
879                                }
880                                m_variableValueSet = _serde::__private::Some(
881                                    match __A::next_value::<Pointer>(&mut __map) {
882                                        _serde::__private::Ok(__val) => __val,
883                                        _serde::__private::Err(__err) => {
884                                            return _serde::__private::Err(__err);
885                                        }
886                                    },
887                                );
888                            }
889                            17usize => {
890                                if _serde::__private::Option::is_some(
891                                    &m_nodeTemplateToCloneMap,
892                                ) {
893                                    return _serde::__private::Err(
894                                        <__A::Error as _serde::de::Error>::duplicate_field(
895                                            "nodeTemplateToCloneMap",
896                                        ),
897                                    );
898                                }
899                                m_nodeTemplateToCloneMap = _serde::__private::Some(
900                                    match __A::next_value::<Pointer>(&mut __map) {
901                                        _serde::__private::Ok(__val) => __val,
902                                        _serde::__private::Err(__err) => {
903                                            return _serde::__private::Err(__err);
904                                        }
905                                    },
906                                );
907                            }
908                            18usize => {
909                                if _serde::__private::Option::is_some(
910                                    &m_nodeCloneToTemplateMap,
911                                ) {
912                                    return _serde::__private::Err(
913                                        <__A::Error as _serde::de::Error>::duplicate_field(
914                                            "nodeCloneToTemplateMap",
915                                        ),
916                                    );
917                                }
918                                m_nodeCloneToTemplateMap = _serde::__private::Some(
919                                    match __A::next_value::<Pointer>(&mut __map) {
920                                        _serde::__private::Ok(__val) => __val,
921                                        _serde::__private::Err(__err) => {
922                                            return _serde::__private::Err(__err);
923                                        }
924                                    },
925                                );
926                            }
927                            19usize => {
928                                if _serde::__private::Option::is_some(
929                                    &m_stateListenerTemplateToCloneMap,
930                                ) {
931                                    return _serde::__private::Err(
932                                        <__A::Error as _serde::de::Error>::duplicate_field(
933                                            "stateListenerTemplateToCloneMap",
934                                        ),
935                                    );
936                                }
937                                m_stateListenerTemplateToCloneMap = _serde::__private::Some(
938                                    match __A::next_value::<Pointer>(&mut __map) {
939                                        _serde::__private::Ok(__val) => __val,
940                                        _serde::__private::Err(__err) => {
941                                            return _serde::__private::Err(__err);
942                                        }
943                                    },
944                                );
945                            }
946                            20usize => {
947                                if _serde::__private::Option::is_some(
948                                    &m_nodePartitionInfo,
949                                ) {
950                                    return _serde::__private::Err(
951                                        <__A::Error as _serde::de::Error>::duplicate_field(
952                                            "nodePartitionInfo",
953                                        ),
954                                    );
955                                }
956                                m_nodePartitionInfo = _serde::__private::Some(
957                                    match __A::next_value::<Pointer>(&mut __map) {
958                                        _serde::__private::Ok(__val) => __val,
959                                        _serde::__private::Err(__err) => {
960                                            return _serde::__private::Err(__err);
961                                        }
962                                    },
963                                );
964                            }
965                            21usize => {
966                                if _serde::__private::Option::is_some(
967                                    &m_numIntermediateOutputs,
968                                ) {
969                                    return _serde::__private::Err(
970                                        <__A::Error as _serde::de::Error>::duplicate_field(
971                                            "numIntermediateOutputs",
972                                        ),
973                                    );
974                                }
975                                m_numIntermediateOutputs = _serde::__private::Some(
976                                    match __A::next_value::<i32>(&mut __map) {
977                                        _serde::__private::Ok(__val) => __val,
978                                        _serde::__private::Err(__err) => {
979                                            return _serde::__private::Err(__err);
980                                        }
981                                    },
982                                );
983                            }
984                            22usize => {
985                                if _serde::__private::Option::is_some(&m_jobs) {
986                                    return _serde::__private::Err(
987                                        <__A::Error as _serde::de::Error>::duplicate_field("jobs"),
988                                    );
989                                }
990                                __A::pad(&mut __map, 0usize, 4usize)?;
991                                m_jobs = _serde::__private::Some(
992                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
993                                        _serde::__private::Ok(__val) => __val,
994                                        _serde::__private::Err(__err) => {
995                                            return _serde::__private::Err(__err);
996                                        }
997                                    },
998                                );
999                            }
1000                            23usize => {
1001                                if _serde::__private::Option::is_some(
1002                                    &m_allPartitionMemory,
1003                                ) {
1004                                    return _serde::__private::Err(
1005                                        <__A::Error as _serde::de::Error>::duplicate_field(
1006                                            "allPartitionMemory",
1007                                        ),
1008                                    );
1009                                }
1010                                m_allPartitionMemory = _serde::__private::Some(
1011                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
1012                                        _serde::__private::Ok(__val) => __val,
1013                                        _serde::__private::Err(__err) => {
1014                                            return _serde::__private::Err(__err);
1015                                        }
1016                                    },
1017                                );
1018                            }
1019                            24usize => {
1020                                if _serde::__private::Option::is_some(&m_numStaticNodes) {
1021                                    return _serde::__private::Err(
1022                                        <__A::Error as _serde::de::Error>::duplicate_field(
1023                                            "numStaticNodes",
1024                                        ),
1025                                    );
1026                                }
1027                                m_numStaticNodes = _serde::__private::Some(
1028                                    match __A::next_value::<i16>(&mut __map) {
1029                                        _serde::__private::Ok(__val) => __val,
1030                                        _serde::__private::Err(__err) => {
1031                                            return _serde::__private::Err(__err);
1032                                        }
1033                                    },
1034                                );
1035                            }
1036                            25usize => {
1037                                if _serde::__private::Option::is_some(&m_nextUniqueId) {
1038                                    return _serde::__private::Err(
1039                                        <__A::Error as _serde::de::Error>::duplicate_field(
1040                                            "nextUniqueId",
1041                                        ),
1042                                    );
1043                                }
1044                                m_nextUniqueId = _serde::__private::Some(
1045                                    match __A::next_value::<i16>(&mut __map) {
1046                                        _serde::__private::Ok(__val) => __val,
1047                                        _serde::__private::Err(__err) => {
1048                                            return _serde::__private::Err(__err);
1049                                        }
1050                                    },
1051                                );
1052                            }
1053                            26usize => {
1054                                if _serde::__private::Option::is_some(&m_isActive) {
1055                                    return _serde::__private::Err(
1056                                        <__A::Error as _serde::de::Error>::duplicate_field(
1057                                            "isActive",
1058                                        ),
1059                                    );
1060                                }
1061                                m_isActive = _serde::__private::Some(
1062                                    match __A::next_value::<bool>(&mut __map) {
1063                                        _serde::__private::Ok(__val) => __val,
1064                                        _serde::__private::Err(__err) => {
1065                                            return _serde::__private::Err(__err);
1066                                        }
1067                                    },
1068                                );
1069                            }
1070                            27usize => {
1071                                if _serde::__private::Option::is_some(&m_isLinked) {
1072                                    return _serde::__private::Err(
1073                                        <__A::Error as _serde::de::Error>::duplicate_field(
1074                                            "isLinked",
1075                                        ),
1076                                    );
1077                                }
1078                                m_isLinked = _serde::__private::Some(
1079                                    match __A::next_value::<bool>(&mut __map) {
1080                                        _serde::__private::Ok(__val) => __val,
1081                                        _serde::__private::Err(__err) => {
1082                                            return _serde::__private::Err(__err);
1083                                        }
1084                                    },
1085                                );
1086                            }
1087                            28usize => {
1088                                if _serde::__private::Option::is_some(
1089                                    &m_updateActiveNodes,
1090                                ) {
1091                                    return _serde::__private::Err(
1092                                        <__A::Error as _serde::de::Error>::duplicate_field(
1093                                            "updateActiveNodes",
1094                                        ),
1095                                    );
1096                                }
1097                                m_updateActiveNodes = _serde::__private::Some(
1098                                    match __A::next_value::<bool>(&mut __map) {
1099                                        _serde::__private::Ok(__val) => __val,
1100                                        _serde::__private::Err(__err) => {
1101                                            return _serde::__private::Err(__err);
1102                                        }
1103                                    },
1104                                );
1105                            }
1106                            29usize => {
1107                                if _serde::__private::Option::is_some(
1108                                    &m_stateOrTransitionChanged,
1109                                ) {
1110                                    return _serde::__private::Err(
1111                                        <__A::Error as _serde::de::Error>::duplicate_field(
1112                                            "stateOrTransitionChanged",
1113                                        ),
1114                                    );
1115                                }
1116                                m_stateOrTransitionChanged = _serde::__private::Some(
1117                                    match __A::next_value::<bool>(&mut __map) {
1118                                        _serde::__private::Ok(__val) => __val,
1119                                        _serde::__private::Err(__err) => {
1120                                            return _serde::__private::Err(__err);
1121                                        }
1122                                    },
1123                                );
1124                            }
1125                            _ => {}
1126                        }
1127                    }
1128                    let m_variableMode = match m_variableMode {
1129                        _serde::__private::Some(__field) => __field,
1130                        _serde::__private::None => {
1131                            return _serde::__private::Err(
1132                                <__A::Error as _serde::de::Error>::missing_field(
1133                                    "variableMode",
1134                                ),
1135                            );
1136                        }
1137                    };
1138                    let m_uniqueIdPool = match m_uniqueIdPool {
1139                        _serde::__private::Some(__field) => __field,
1140                        _serde::__private::None => {
1141                            return _serde::__private::Err(
1142                                <__A::Error as _serde::de::Error>::missing_field(
1143                                    "uniqueIdPool",
1144                                ),
1145                            );
1146                        }
1147                    };
1148                    let m_idToStateMachineTemplateMap = match m_idToStateMachineTemplateMap {
1149                        _serde::__private::Some(__field) => __field,
1150                        _serde::__private::None => {
1151                            return _serde::__private::Err(
1152                                <__A::Error as _serde::de::Error>::missing_field(
1153                                    "idToStateMachineTemplateMap",
1154                                ),
1155                            );
1156                        }
1157                    };
1158                    let m_mirroredExternalIdMap = match m_mirroredExternalIdMap {
1159                        _serde::__private::Some(__field) => __field,
1160                        _serde::__private::None => {
1161                            return _serde::__private::Err(
1162                                <__A::Error as _serde::de::Error>::missing_field(
1163                                    "mirroredExternalIdMap",
1164                                ),
1165                            );
1166                        }
1167                    };
1168                    let m_pseudoRandomGenerator = match m_pseudoRandomGenerator {
1169                        _serde::__private::Some(__field) => __field,
1170                        _serde::__private::None => {
1171                            return _serde::__private::Err(
1172                                <__A::Error as _serde::de::Error>::missing_field(
1173                                    "pseudoRandomGenerator",
1174                                ),
1175                            );
1176                        }
1177                    };
1178                    let m_rootGenerator = match m_rootGenerator {
1179                        _serde::__private::Some(__field) => __field,
1180                        _serde::__private::None => {
1181                            return _serde::__private::Err(
1182                                <__A::Error as _serde::de::Error>::missing_field(
1183                                    "rootGenerator",
1184                                ),
1185                            );
1186                        }
1187                    };
1188                    let m_data = match m_data {
1189                        _serde::__private::Some(__field) => __field,
1190                        _serde::__private::None => {
1191                            return _serde::__private::Err(
1192                                <__A::Error as _serde::de::Error>::missing_field("data"),
1193                            );
1194                        }
1195                    };
1196                    let m_rootGeneratorClone = match m_rootGeneratorClone {
1197                        _serde::__private::Some(__field) => __field,
1198                        _serde::__private::None => {
1199                            return _serde::__private::Err(
1200                                <__A::Error as _serde::de::Error>::missing_field(
1201                                    "rootGeneratorClone",
1202                                ),
1203                            );
1204                        }
1205                    };
1206                    let m_activeNodes = match m_activeNodes {
1207                        _serde::__private::Some(__field) => __field,
1208                        _serde::__private::None => {
1209                            return _serde::__private::Err(
1210                                <__A::Error as _serde::de::Error>::missing_field(
1211                                    "activeNodes",
1212                                ),
1213                            );
1214                        }
1215                    };
1216                    let m_activeNodeTemplateToIndexMap = match m_activeNodeTemplateToIndexMap {
1217                        _serde::__private::Some(__field) => __field,
1218                        _serde::__private::None => {
1219                            return _serde::__private::Err(
1220                                <__A::Error as _serde::de::Error>::missing_field(
1221                                    "activeNodeTemplateToIndexMap",
1222                                ),
1223                            );
1224                        }
1225                    };
1226                    let m_activeNodesChildrenIndices = match m_activeNodesChildrenIndices {
1227                        _serde::__private::Some(__field) => __field,
1228                        _serde::__private::None => {
1229                            return _serde::__private::Err(
1230                                <__A::Error as _serde::de::Error>::missing_field(
1231                                    "activeNodesChildrenIndices",
1232                                ),
1233                            );
1234                        }
1235                    };
1236                    let m_globalTransitionData = match m_globalTransitionData {
1237                        _serde::__private::Some(__field) => __field,
1238                        _serde::__private::None => {
1239                            return _serde::__private::Err(
1240                                <__A::Error as _serde::de::Error>::missing_field(
1241                                    "globalTransitionData",
1242                                ),
1243                            );
1244                        }
1245                    };
1246                    let m_eventIdMap = match m_eventIdMap {
1247                        _serde::__private::Some(__field) => __field,
1248                        _serde::__private::None => {
1249                            return _serde::__private::Err(
1250                                <__A::Error as _serde::de::Error>::missing_field(
1251                                    "eventIdMap",
1252                                ),
1253                            );
1254                        }
1255                    };
1256                    let m_attributeIdMap = match m_attributeIdMap {
1257                        _serde::__private::Some(__field) => __field,
1258                        _serde::__private::None => {
1259                            return _serde::__private::Err(
1260                                <__A::Error as _serde::de::Error>::missing_field(
1261                                    "attributeIdMap",
1262                                ),
1263                            );
1264                        }
1265                    };
1266                    let m_variableIdMap = match m_variableIdMap {
1267                        _serde::__private::Some(__field) => __field,
1268                        _serde::__private::None => {
1269                            return _serde::__private::Err(
1270                                <__A::Error as _serde::de::Error>::missing_field(
1271                                    "variableIdMap",
1272                                ),
1273                            );
1274                        }
1275                    };
1276                    let m_characterPropertyIdMap = match m_characterPropertyIdMap {
1277                        _serde::__private::Some(__field) => __field,
1278                        _serde::__private::None => {
1279                            return _serde::__private::Err(
1280                                <__A::Error as _serde::de::Error>::missing_field(
1281                                    "characterPropertyIdMap",
1282                                ),
1283                            );
1284                        }
1285                    };
1286                    let m_variableValueSet = match m_variableValueSet {
1287                        _serde::__private::Some(__field) => __field,
1288                        _serde::__private::None => {
1289                            return _serde::__private::Err(
1290                                <__A::Error as _serde::de::Error>::missing_field(
1291                                    "variableValueSet",
1292                                ),
1293                            );
1294                        }
1295                    };
1296                    let m_nodeTemplateToCloneMap = match m_nodeTemplateToCloneMap {
1297                        _serde::__private::Some(__field) => __field,
1298                        _serde::__private::None => {
1299                            return _serde::__private::Err(
1300                                <__A::Error as _serde::de::Error>::missing_field(
1301                                    "nodeTemplateToCloneMap",
1302                                ),
1303                            );
1304                        }
1305                    };
1306                    let m_nodeCloneToTemplateMap = match m_nodeCloneToTemplateMap {
1307                        _serde::__private::Some(__field) => __field,
1308                        _serde::__private::None => {
1309                            return _serde::__private::Err(
1310                                <__A::Error as _serde::de::Error>::missing_field(
1311                                    "nodeCloneToTemplateMap",
1312                                ),
1313                            );
1314                        }
1315                    };
1316                    let m_stateListenerTemplateToCloneMap = match m_stateListenerTemplateToCloneMap {
1317                        _serde::__private::Some(__field) => __field,
1318                        _serde::__private::None => {
1319                            return _serde::__private::Err(
1320                                <__A::Error as _serde::de::Error>::missing_field(
1321                                    "stateListenerTemplateToCloneMap",
1322                                ),
1323                            );
1324                        }
1325                    };
1326                    let m_nodePartitionInfo = match m_nodePartitionInfo {
1327                        _serde::__private::Some(__field) => __field,
1328                        _serde::__private::None => {
1329                            return _serde::__private::Err(
1330                                <__A::Error as _serde::de::Error>::missing_field(
1331                                    "nodePartitionInfo",
1332                                ),
1333                            );
1334                        }
1335                    };
1336                    let m_numIntermediateOutputs = match m_numIntermediateOutputs {
1337                        _serde::__private::Some(__field) => __field,
1338                        _serde::__private::None => {
1339                            return _serde::__private::Err(
1340                                <__A::Error as _serde::de::Error>::missing_field(
1341                                    "numIntermediateOutputs",
1342                                ),
1343                            );
1344                        }
1345                    };
1346                    let m_jobs = match m_jobs {
1347                        _serde::__private::Some(__field) => __field,
1348                        _serde::__private::None => {
1349                            return _serde::__private::Err(
1350                                <__A::Error as _serde::de::Error>::missing_field("jobs"),
1351                            );
1352                        }
1353                    };
1354                    let m_allPartitionMemory = match m_allPartitionMemory {
1355                        _serde::__private::Some(__field) => __field,
1356                        _serde::__private::None => {
1357                            return _serde::__private::Err(
1358                                <__A::Error as _serde::de::Error>::missing_field(
1359                                    "allPartitionMemory",
1360                                ),
1361                            );
1362                        }
1363                    };
1364                    let m_numStaticNodes = match m_numStaticNodes {
1365                        _serde::__private::Some(__field) => __field,
1366                        _serde::__private::None => {
1367                            return _serde::__private::Err(
1368                                <__A::Error as _serde::de::Error>::missing_field(
1369                                    "numStaticNodes",
1370                                ),
1371                            );
1372                        }
1373                    };
1374                    let m_nextUniqueId = match m_nextUniqueId {
1375                        _serde::__private::Some(__field) => __field,
1376                        _serde::__private::None => {
1377                            return _serde::__private::Err(
1378                                <__A::Error as _serde::de::Error>::missing_field(
1379                                    "nextUniqueId",
1380                                ),
1381                            );
1382                        }
1383                    };
1384                    let m_isActive = match m_isActive {
1385                        _serde::__private::Some(__field) => __field,
1386                        _serde::__private::None => {
1387                            return _serde::__private::Err(
1388                                <__A::Error as _serde::de::Error>::missing_field("isActive"),
1389                            );
1390                        }
1391                    };
1392                    let m_isLinked = match m_isLinked {
1393                        _serde::__private::Some(__field) => __field,
1394                        _serde::__private::None => {
1395                            return _serde::__private::Err(
1396                                <__A::Error as _serde::de::Error>::missing_field("isLinked"),
1397                            );
1398                        }
1399                    };
1400                    let m_updateActiveNodes = match m_updateActiveNodes {
1401                        _serde::__private::Some(__field) => __field,
1402                        _serde::__private::None => {
1403                            return _serde::__private::Err(
1404                                <__A::Error as _serde::de::Error>::missing_field(
1405                                    "updateActiveNodes",
1406                                ),
1407                            );
1408                        }
1409                    };
1410                    let m_stateOrTransitionChanged = match m_stateOrTransitionChanged {
1411                        _serde::__private::Some(__field) => __field,
1412                        _serde::__private::None => {
1413                            return _serde::__private::Err(
1414                                <__A::Error as _serde::de::Error>::missing_field(
1415                                    "stateOrTransitionChanged",
1416                                ),
1417                            );
1418                        }
1419                    };
1420                    _serde::__private::Ok(hkbBehaviorGraph {
1421                        __ptr,
1422                        parent,
1423                        m_variableMode,
1424                        m_uniqueIdPool,
1425                        m_idToStateMachineTemplateMap,
1426                        m_mirroredExternalIdMap,
1427                        m_pseudoRandomGenerator,
1428                        m_rootGenerator,
1429                        m_data,
1430                        m_rootGeneratorClone,
1431                        m_activeNodes,
1432                        m_activeNodeTemplateToIndexMap,
1433                        m_activeNodesChildrenIndices,
1434                        m_globalTransitionData,
1435                        m_eventIdMap,
1436                        m_attributeIdMap,
1437                        m_variableIdMap,
1438                        m_characterPropertyIdMap,
1439                        m_variableValueSet,
1440                        m_nodeTemplateToCloneMap,
1441                        m_nodeCloneToTemplateMap,
1442                        m_stateListenerTemplateToCloneMap,
1443                        m_nodePartitionInfo,
1444                        m_numIntermediateOutputs,
1445                        m_jobs,
1446                        m_allPartitionMemory,
1447                        m_numStaticNodes,
1448                        m_nextUniqueId,
1449                        m_isActive,
1450                        m_isLinked,
1451                        m_updateActiveNodes,
1452                        m_stateOrTransitionChanged,
1453                    })
1454                }
1455                #[allow(clippy::manual_unwrap_or_default)]
1456                fn visit_struct<__A>(
1457                    self,
1458                    mut __map: __A,
1459                ) -> _serde::__private::Result<Self::Value, __A::Error>
1460                where
1461                    __A: _serde::de::MapAccess<'de>,
1462                {
1463                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1464                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1465                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1466                    let mut m_variableMode: _serde::__private::Option<VariableMode> = _serde::__private::None;
1467                    let mut m_rootGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
1468                    let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
1469                    while let _serde::__private::Some(__key) = {
1470                        __A::next_key::<__Field>(&mut __map)?
1471                    } {
1472                        match __key {
1473                            __Field::m_variableBindingSet => {
1474                                #[cfg(
1475                                    any(feature = "strict", feature = "ignore_duplicates")
1476                                )]
1477                                if _serde::__private::Option::is_some(
1478                                    &m_variableBindingSet,
1479                                ) {
1480                                    #[cfg(feature = "ignore_duplicates")]
1481                                    {
1482                                        __A::skip_value(&mut __map)?;
1483                                        continue;
1484                                    }
1485                                    #[cfg(feature = "strict")]
1486                                    return _serde::__private::Err(
1487                                        <__A::Error as _serde::de::Error>::duplicate_field(
1488                                            "variableBindingSet",
1489                                        ),
1490                                    );
1491                                }
1492                                m_variableBindingSet = _serde::__private::Some(
1493                                    match __A::next_value::<Pointer>(&mut __map) {
1494                                        _serde::__private::Ok(__val) => __val,
1495                                        _serde::__private::Err(__err) => {
1496                                            return _serde::__private::Err(__err);
1497                                        }
1498                                    },
1499                                );
1500                            }
1501                            __Field::m_userData => {
1502                                #[cfg(
1503                                    any(feature = "strict", feature = "ignore_duplicates")
1504                                )]
1505                                if _serde::__private::Option::is_some(&m_userData) {
1506                                    #[cfg(feature = "ignore_duplicates")]
1507                                    {
1508                                        __A::skip_value(&mut __map)?;
1509                                        continue;
1510                                    }
1511                                    #[cfg(feature = "strict")]
1512                                    return _serde::__private::Err(
1513                                        <__A::Error as _serde::de::Error>::duplicate_field(
1514                                            "userData",
1515                                        ),
1516                                    );
1517                                }
1518                                m_userData = _serde::__private::Some(
1519                                    match __A::next_value::<Ulong>(&mut __map) {
1520                                        _serde::__private::Ok(__val) => __val,
1521                                        _serde::__private::Err(__err) => {
1522                                            return _serde::__private::Err(__err);
1523                                        }
1524                                    },
1525                                );
1526                            }
1527                            __Field::m_name => {
1528                                #[cfg(
1529                                    any(feature = "strict", feature = "ignore_duplicates")
1530                                )]
1531                                if _serde::__private::Option::is_some(&m_name) {
1532                                    #[cfg(feature = "ignore_duplicates")]
1533                                    {
1534                                        __A::skip_value(&mut __map)?;
1535                                        continue;
1536                                    }
1537                                    #[cfg(feature = "strict")]
1538                                    return _serde::__private::Err(
1539                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
1540                                    );
1541                                }
1542                                m_name = _serde::__private::Some(
1543                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
1544                                        _serde::__private::Ok(__val) => __val,
1545                                        _serde::__private::Err(__err) => {
1546                                            return _serde::__private::Err(__err);
1547                                        }
1548                                    },
1549                                );
1550                            }
1551                            __Field::m_variableMode => {
1552                                #[cfg(
1553                                    any(feature = "strict", feature = "ignore_duplicates")
1554                                )]
1555                                if _serde::__private::Option::is_some(&m_variableMode) {
1556                                    #[cfg(feature = "ignore_duplicates")]
1557                                    {
1558                                        __A::skip_value(&mut __map)?;
1559                                        continue;
1560                                    }
1561                                    #[cfg(feature = "strict")]
1562                                    return _serde::__private::Err(
1563                                        <__A::Error as _serde::de::Error>::duplicate_field(
1564                                            "variableMode",
1565                                        ),
1566                                    );
1567                                }
1568                                m_variableMode = _serde::__private::Some(
1569                                    match __A::next_value::<VariableMode>(&mut __map) {
1570                                        _serde::__private::Ok(__val) => __val,
1571                                        _serde::__private::Err(__err) => {
1572                                            return _serde::__private::Err(__err);
1573                                        }
1574                                    },
1575                                );
1576                            }
1577                            __Field::m_rootGenerator => {
1578                                #[cfg(
1579                                    any(feature = "strict", feature = "ignore_duplicates")
1580                                )]
1581                                if _serde::__private::Option::is_some(&m_rootGenerator) {
1582                                    #[cfg(feature = "ignore_duplicates")]
1583                                    {
1584                                        __A::skip_value(&mut __map)?;
1585                                        continue;
1586                                    }
1587                                    #[cfg(feature = "strict")]
1588                                    return _serde::__private::Err(
1589                                        <__A::Error as _serde::de::Error>::duplicate_field(
1590                                            "rootGenerator",
1591                                        ),
1592                                    );
1593                                }
1594                                m_rootGenerator = _serde::__private::Some(
1595                                    match __A::next_value::<Pointer>(&mut __map) {
1596                                        _serde::__private::Ok(__val) => __val,
1597                                        _serde::__private::Err(__err) => {
1598                                            return _serde::__private::Err(__err);
1599                                        }
1600                                    },
1601                                );
1602                            }
1603                            __Field::m_data => {
1604                                #[cfg(
1605                                    any(feature = "strict", feature = "ignore_duplicates")
1606                                )]
1607                                if _serde::__private::Option::is_some(&m_data) {
1608                                    #[cfg(feature = "ignore_duplicates")]
1609                                    {
1610                                        __A::skip_value(&mut __map)?;
1611                                        continue;
1612                                    }
1613                                    #[cfg(feature = "strict")]
1614                                    return _serde::__private::Err(
1615                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
1616                                    );
1617                                }
1618                                m_data = _serde::__private::Some(
1619                                    match __A::next_value::<Pointer>(&mut __map) {
1620                                        _serde::__private::Ok(__val) => __val,
1621                                        _serde::__private::Err(__err) => {
1622                                            return _serde::__private::Err(__err);
1623                                        }
1624                                    },
1625                                );
1626                            }
1627                            _ => __A::skip_value(&mut __map)?,
1628                        }
1629                    }
1630                    let m_variableBindingSet = match m_variableBindingSet {
1631                        _serde::__private::Some(__field) => __field,
1632                        _serde::__private::None => {
1633                            #[cfg(feature = "strict")]
1634                            return _serde::__private::Err(
1635                                <__A::Error as _serde::de::Error>::missing_field(
1636                                    "variableBindingSet",
1637                                ),
1638                            );
1639                            #[cfg(not(feature = "strict"))] Default::default()
1640                        }
1641                    };
1642                    let m_userData = match m_userData {
1643                        _serde::__private::Some(__field) => __field,
1644                        _serde::__private::None => {
1645                            #[cfg(feature = "strict")]
1646                            return _serde::__private::Err(
1647                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1648                            );
1649                            #[cfg(not(feature = "strict"))] Default::default()
1650                        }
1651                    };
1652                    let m_name = match m_name {
1653                        _serde::__private::Some(__field) => __field,
1654                        _serde::__private::None => {
1655                            #[cfg(feature = "strict")]
1656                            return _serde::__private::Err(
1657                                <__A::Error as _serde::de::Error>::missing_field("name"),
1658                            );
1659                            #[cfg(not(feature = "strict"))] Default::default()
1660                        }
1661                    };
1662                    let m_variableMode = match m_variableMode {
1663                        _serde::__private::Some(__field) => __field,
1664                        _serde::__private::None => {
1665                            #[cfg(feature = "strict")]
1666                            return _serde::__private::Err(
1667                                <__A::Error as _serde::de::Error>::missing_field(
1668                                    "variableMode",
1669                                ),
1670                            );
1671                            #[cfg(not(feature = "strict"))] Default::default()
1672                        }
1673                    };
1674                    let m_rootGenerator = match m_rootGenerator {
1675                        _serde::__private::Some(__field) => __field,
1676                        _serde::__private::None => {
1677                            #[cfg(feature = "strict")]
1678                            return _serde::__private::Err(
1679                                <__A::Error as _serde::de::Error>::missing_field(
1680                                    "rootGenerator",
1681                                ),
1682                            );
1683                            #[cfg(not(feature = "strict"))] Default::default()
1684                        }
1685                    };
1686                    let m_data = match m_data {
1687                        _serde::__private::Some(__field) => __field,
1688                        _serde::__private::None => {
1689                            #[cfg(feature = "strict")]
1690                            return _serde::__private::Err(
1691                                <__A::Error as _serde::de::Error>::missing_field("data"),
1692                            );
1693                            #[cfg(not(feature = "strict"))] Default::default()
1694                        }
1695                    };
1696                    let __ptr = None;
1697                    let parent = hkBaseObject { __ptr };
1698                    let parent = hkReferencedObject {
1699                        __ptr,
1700                        parent,
1701                        ..Default::default()
1702                    };
1703                    let parent = hkbBindable {
1704                        __ptr,
1705                        parent,
1706                        m_variableBindingSet,
1707                        ..Default::default()
1708                    };
1709                    let parent = hkbNode {
1710                        __ptr,
1711                        parent,
1712                        m_userData,
1713                        m_name,
1714                        ..Default::default()
1715                    };
1716                    let parent = hkbGenerator { __ptr, parent };
1717                    let __ptr = __A::class_ptr(&mut __map);
1718                    _serde::__private::Ok(hkbBehaviorGraph {
1719                        __ptr,
1720                        parent,
1721                        m_variableMode,
1722                        m_rootGenerator,
1723                        m_data,
1724                        ..Default::default()
1725                    })
1726                }
1727            }
1728            const FIELDS: &[&str] = &[
1729                "variableMode",
1730                "uniqueIdPool",
1731                "idToStateMachineTemplateMap",
1732                "mirroredExternalIdMap",
1733                "pseudoRandomGenerator",
1734                "rootGenerator",
1735                "data",
1736                "rootGeneratorClone",
1737                "activeNodes",
1738                "activeNodeTemplateToIndexMap",
1739                "activeNodesChildrenIndices",
1740                "globalTransitionData",
1741                "eventIdMap",
1742                "attributeIdMap",
1743                "variableIdMap",
1744                "characterPropertyIdMap",
1745                "variableValueSet",
1746                "nodeTemplateToCloneMap",
1747                "nodeCloneToTemplateMap",
1748                "stateListenerTemplateToCloneMap",
1749                "nodePartitionInfo",
1750                "numIntermediateOutputs",
1751                "jobs",
1752                "allPartitionMemory",
1753                "numStaticNodes",
1754                "nextUniqueId",
1755                "isActive",
1756                "isLinked",
1757                "updateActiveNodes",
1758                "stateOrTransitionChanged",
1759            ];
1760            _serde::Deserializer::deserialize_struct(
1761                deserializer,
1762                "hkbBehaviorGraph",
1763                FIELDS,
1764                __hkbBehaviorGraphVisitor {
1765                    marker: _serde::__private::PhantomData::<hkbBehaviorGraph>,
1766                    lifetime: _serde::__private::PhantomData,
1767                },
1768            )
1769        }
1770    }
1771};
1772/// # C++ Info
1773/// - name: `VariableMode`(ctype: `hkEnum<VariableMode, hkInt8>`)
1774#[allow(non_upper_case_globals, non_snake_case)]
1775#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1776#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1777#[derive(
1778    Debug,
1779    Clone,
1780    Default,
1781    PartialEq,
1782    Eq,
1783    PartialOrd,
1784    Ord,
1785    num_derive::ToPrimitive,
1786    num_derive::FromPrimitive,
1787)]
1788pub enum VariableMode {
1789    #[default]
1790    VARIABLE_MODE_DISCARD_WHEN_INACTIVE = 0isize,
1791    VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE = 1isize,
1792}
1793const _: () = {
1794    use havok_serde as __serde;
1795    impl __serde::Serialize for VariableMode {
1796        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1797        where
1798            S: __serde::ser::Serializer,
1799        {
1800            let mut __serializer = __serializer.serialize_enum_flags()?;
1801            match self {
1802                Self::VARIABLE_MODE_DISCARD_WHEN_INACTIVE => {
1803                    __serializer
1804                        .serialize_field("VARIABLE_MODE_DISCARD_WHEN_INACTIVE", &0u64)
1805                }
1806                Self::VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE => {
1807                    __serializer
1808                        .serialize_field(
1809                            "VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE",
1810                            &1u64,
1811                        )
1812                }
1813            }?;
1814            use num_traits::ToPrimitive as _;
1815            let num = self
1816                .to_i8()
1817                .ok_or(S::Error::custom("Failed enum VariableMode to_i8"))?;
1818            __serializer.serialize_bits(&num)?;
1819            __serializer.end()
1820        }
1821    }
1822};
1823#[doc(hidden)]
1824#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1825const _: () = {
1826    #[allow(unused_extern_crates, clippy::useless_attribute)]
1827    extern crate havok_serde as _serde;
1828    #[automatically_derived]
1829    impl<'de> _serde::Deserialize<'de> for VariableMode {
1830        fn deserialize<__D>(
1831            __deserializer: __D,
1832        ) -> _serde::__private::Result<Self, __D::Error>
1833        where
1834            __D: _serde::Deserializer<'de>,
1835        {
1836            #[allow(non_camel_case_types)]
1837            #[doc(hidden)]
1838            enum __Field {
1839                __field0,
1840                __field1,
1841            }
1842            #[doc(hidden)]
1843            struct __FieldVisitor;
1844            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1845                type Value = __Field;
1846                fn expecting(
1847                    &self,
1848                    __formatter: &mut _serde::__private::Formatter,
1849                ) -> _serde::__private::fmt::Result {
1850                    _serde::__private::Formatter::write_str(
1851                        __formatter,
1852                        "variant identifier",
1853                    )
1854                }
1855                fn visit_int8<__E>(
1856                    self,
1857                    __value: i8,
1858                ) -> _serde::__private::Result<Self::Value, __E>
1859                where
1860                    __E: _serde::de::Error,
1861                {
1862                    match __value {
1863                        0i8 => _serde::__private::Ok(__Field::__field0),
1864                        1i8 => _serde::__private::Ok(__Field::__field1),
1865                        _ => {
1866                            _serde::__private::Err(
1867                                _serde::de::Error::invalid_value(
1868                                    _serde::de::Unexpected::Int8(__value),
1869                                    &"value(i8) of variant is one of 0, 1",
1870                                ),
1871                            )
1872                        }
1873                    }
1874                }
1875                fn visit_stringptr<__E>(
1876                    self,
1877                    __value: StringPtr<'de>,
1878                ) -> _serde::__private::Result<Self::Value, __E>
1879                where
1880                    __E: _serde::de::Error,
1881                {
1882                    if let Some(__value) = __value.into_inner() {
1883                        match __value.as_ref() {
1884                            v if v == "0"
1885                                || v
1886                                    .eq_ignore_ascii_case(
1887                                        "VARIABLE_MODE_DISCARD_WHEN_INACTIVE",
1888                                    ) => _serde::__private::Ok(__Field::__field0),
1889                            v if v == "1"
1890                                || v
1891                                    .eq_ignore_ascii_case(
1892                                        "VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE",
1893                                    ) => _serde::__private::Ok(__Field::__field1),
1894                            _ => {
1895                                _serde::__private::Err(
1896                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1897                                )
1898                            }
1899                        }
1900                    } else {
1901                        _serde::__private::Err(
1902                            _serde::de::Error::unknown_variant("None", VARIANTS),
1903                        )
1904                    }
1905                }
1906            }
1907            impl<'de> _serde::Deserialize<'de> for __Field {
1908                #[inline]
1909                fn deserialize<__D>(
1910                    __deserializer: __D,
1911                ) -> _serde::__private::Result<Self, __D::Error>
1912                where
1913                    __D: _serde::Deserializer<'de>,
1914                {
1915                    _serde::Deserializer::deserialize_identifier(
1916                        __deserializer,
1917                        _serde::de::ReadEnumSize::Int8,
1918                        __FieldVisitor,
1919                    )
1920                }
1921            }
1922            #[doc(hidden)]
1923            struct __Visitor<'de> {
1924                marker: _serde::__private::PhantomData<VariableMode>,
1925                lifetime: _serde::__private::PhantomData<&'de ()>,
1926            }
1927            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1928                type Value = VariableMode;
1929                fn expecting(
1930                    &self,
1931                    __formatter: &mut _serde::__private::Formatter,
1932                ) -> _serde::__private::fmt::Result {
1933                    _serde::__private::Formatter::write_str(
1934                        __formatter,
1935                        "enum VariableMode",
1936                    )
1937                }
1938                fn visit_enum<__A>(
1939                    self,
1940                    __data: __A,
1941                ) -> _serde::__private::Result<Self::Value, __A::Error>
1942                where
1943                    __A: _serde::de::EnumAccess<'de>,
1944                {
1945                    match _serde::de::EnumAccess::variant(__data)? {
1946                        (__Field::__field0, __variant) => {
1947                            _serde::de::VariantAccess::unit_variant(__variant)?;
1948                            _serde::__private::Ok(
1949                                VariableMode::VARIABLE_MODE_DISCARD_WHEN_INACTIVE,
1950                            )
1951                        }
1952                        (__Field::__field1, __variant) => {
1953                            _serde::de::VariantAccess::unit_variant(__variant)?;
1954                            _serde::__private::Ok(
1955                                VariableMode::VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE,
1956                            )
1957                        }
1958                    }
1959                }
1960            }
1961            #[doc(hidden)]
1962            const VARIANTS: &'static [&'static str] = &[
1963                "VARIABLE_MODE_DISCARD_WHEN_INACTIVE",
1964                "VARIABLE_MODE_MAINTAIN_VALUES_WHEN_INACTIVE",
1965            ];
1966            _serde::Deserializer::deserialize_enum(
1967                __deserializer,
1968                "VariableMode",
1969                VARIANTS,
1970                __Visitor {
1971                    marker: _serde::__private::PhantomData::<VariableMode>,
1972                    lifetime: _serde::__private::PhantomData,
1973                },
1974            )
1975        }
1976    }
1977};