havok_classes/generated/
hkbBehaviorGraphData_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbBehaviorGraphData`
5/// - version: `2`
6/// - signature: `0x95aca5d`
7/// - size: ` 88`(x86)/`128`(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 hkbBehaviorGraphData {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `attributeDefaults`(ctype: `hkArray<hkReal>`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "attributeDefaults"))]
35    #[cfg_attr(feature = "serde", serde(rename = "attributeDefaults"))]
36    pub m_attributeDefaults: Vec<f32>,
37    /// # C++ Info
38    /// - name: `variableInfos`(ctype: `hkArray<struct hkbVariableInfo>`)
39    /// - offset: ` 20`(x86)/` 32`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "variableInfos"))]
42    #[cfg_attr(feature = "serde", serde(rename = "variableInfos"))]
43    pub m_variableInfos: Vec<hkbVariableInfo>,
44    /// # C++ Info
45    /// - name: `characterPropertyInfos`(ctype: `hkArray<struct hkbVariableInfo>`)
46    /// - offset: ` 32`(x86)/` 48`(x86_64)
47    /// - type_size: ` 12`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "characterPropertyInfos"))]
49    #[cfg_attr(feature = "serde", serde(rename = "characterPropertyInfos"))]
50    pub m_characterPropertyInfos: Vec<hkbVariableInfo>,
51    /// # C++ Info
52    /// - name: `eventInfos`(ctype: `hkArray<struct hkbEventInfo>`)
53    /// - offset: ` 44`(x86)/` 64`(x86_64)
54    /// - type_size: ` 12`(x86)/` 16`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "eventInfos"))]
56    #[cfg_attr(feature = "serde", serde(rename = "eventInfos"))]
57    pub m_eventInfos: Vec<hkbEventInfo>,
58    /// # C++ Info
59    /// - name: `wordMinVariableValues`(ctype: `hkArray<struct hkbVariableValue>`)
60    /// - offset: ` 56`(x86)/` 80`(x86_64)
61    /// - type_size: ` 12`(x86)/` 16`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "wordMinVariableValues"))]
63    #[cfg_attr(feature = "serde", serde(rename = "wordMinVariableValues"))]
64    pub m_wordMinVariableValues: Vec<hkbVariableValue>,
65    /// # C++ Info
66    /// - name: `wordMaxVariableValues`(ctype: `hkArray<struct hkbVariableValue>`)
67    /// - offset: ` 68`(x86)/` 96`(x86_64)
68    /// - type_size: ` 12`(x86)/` 16`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "wordMaxVariableValues"))]
70    #[cfg_attr(feature = "serde", serde(rename = "wordMaxVariableValues"))]
71    pub m_wordMaxVariableValues: Vec<hkbVariableValue>,
72    /// # C++ Info
73    /// - name: `variableInitialValues`(ctype: `struct hkbVariableValueSet*`)
74    /// - offset: ` 80`(x86)/`112`(x86_64)
75    /// - type_size: `  4`(x86)/`  8`(x86_64)
76    #[cfg_attr(feature = "json_schema", schemars(rename = "variableInitialValues"))]
77    #[cfg_attr(feature = "serde", serde(rename = "variableInitialValues"))]
78    pub m_variableInitialValues: Pointer,
79    /// # C++ Info
80    /// - name: `stringData`(ctype: `struct hkbBehaviorGraphStringData*`)
81    /// - offset: ` 84`(x86)/`120`(x86_64)
82    /// - type_size: `  4`(x86)/`  8`(x86_64)
83    #[cfg_attr(feature = "json_schema", schemars(rename = "stringData"))]
84    #[cfg_attr(feature = "serde", serde(rename = "stringData"))]
85    pub m_stringData: Pointer,
86}
87const _: () = {
88    use havok_serde as _serde;
89    impl _serde::HavokClass for hkbBehaviorGraphData {
90        #[inline]
91        fn name(&self) -> &'static str {
92            "hkbBehaviorGraphData"
93        }
94        #[inline]
95        fn signature(&self) -> _serde::__private::Signature {
96            _serde::__private::Signature::new(0x95aca5d)
97        }
98        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
99        fn deps_indexes(&self) -> Vec<usize> {
100            let mut v = Vec::new();
101            v.extend(
102                self
103                    .m_variableInfos
104                    .iter()
105                    .flat_map(|class| class.deps_indexes())
106                    .collect::<Vec<usize>>(),
107            );
108            v.extend(
109                self
110                    .m_characterPropertyInfos
111                    .iter()
112                    .flat_map(|class| class.deps_indexes())
113                    .collect::<Vec<usize>>(),
114            );
115            v.extend(
116                self
117                    .m_eventInfos
118                    .iter()
119                    .flat_map(|class| class.deps_indexes())
120                    .collect::<Vec<usize>>(),
121            );
122            v.extend(
123                self
124                    .m_wordMinVariableValues
125                    .iter()
126                    .flat_map(|class| class.deps_indexes())
127                    .collect::<Vec<usize>>(),
128            );
129            v.extend(
130                self
131                    .m_wordMaxVariableValues
132                    .iter()
133                    .flat_map(|class| class.deps_indexes())
134                    .collect::<Vec<usize>>(),
135            );
136            v.push(self.m_variableInitialValues.get());
137            v.push(self.m_stringData.get());
138            v
139        }
140    }
141    impl _serde::Serialize for hkbBehaviorGraphData {
142        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
143        where
144            S: _serde::ser::Serializer,
145        {
146            let class_meta = self
147                .__ptr
148                .map(|name| (name, _serde::__private::Signature::new(0x95aca5d)));
149            let mut serializer = __serializer
150                .serialize_struct("hkbBehaviorGraphData", class_meta, (88u64, 128u64))?;
151            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
152            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
153            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
154            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
155            serializer
156                .serialize_array_field(
157                    "attributeDefaults",
158                    &self.m_attributeDefaults,
159                    TypeSize::NonPtr,
160                )?;
161            serializer
162                .serialize_array_field(
163                    "variableInfos",
164                    &self.m_variableInfos,
165                    TypeSize::Struct {
166                        size_x86: 6u64,
167                        size_x86_64: 6u64,
168                    },
169                )?;
170            serializer
171                .serialize_array_field(
172                    "characterPropertyInfos",
173                    &self.m_characterPropertyInfos,
174                    TypeSize::Struct {
175                        size_x86: 6u64,
176                        size_x86_64: 6u64,
177                    },
178                )?;
179            serializer
180                .serialize_array_field(
181                    "eventInfos",
182                    &self.m_eventInfos,
183                    TypeSize::Struct {
184                        size_x86: 4u64,
185                        size_x86_64: 4u64,
186                    },
187                )?;
188            serializer
189                .serialize_array_field(
190                    "wordMinVariableValues",
191                    &self.m_wordMinVariableValues,
192                    TypeSize::Struct {
193                        size_x86: 4u64,
194                        size_x86_64: 4u64,
195                    },
196                )?;
197            serializer
198                .serialize_array_field(
199                    "wordMaxVariableValues",
200                    &self.m_wordMaxVariableValues,
201                    TypeSize::Struct {
202                        size_x86: 4u64,
203                        size_x86_64: 4u64,
204                    },
205                )?;
206            serializer
207                .serialize_field(
208                    "variableInitialValues",
209                    &self.m_variableInitialValues,
210                )?;
211            serializer.serialize_field("stringData", &self.m_stringData)?;
212            serializer.end()
213        }
214    }
215};
216#[doc(hidden)]
217#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
218const _: () = {
219    use havok_serde as _serde;
220    #[automatically_derived]
221    impl<'de> _serde::Deserialize<'de> for hkbBehaviorGraphData {
222        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
223        where
224            __D: _serde::Deserializer<'de>,
225        {
226            #[allow(non_camel_case_types)]
227            enum __Field {
228                m_attributeDefaults,
229                m_variableInfos,
230                m_characterPropertyInfos,
231                m_eventInfos,
232                m_wordMinVariableValues,
233                m_wordMaxVariableValues,
234                m_variableInitialValues,
235                m_stringData,
236                __ignore,
237            }
238            struct __FieldVisitor;
239            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
240                type Value = __Field;
241                fn expecting(
242                    &self,
243                    __formatter: &mut core::fmt::Formatter,
244                ) -> core::fmt::Result {
245                    core::fmt::Formatter::write_str(__formatter, "field identifier")
246                }
247                /// Intended for use in XML.
248                #[allow(clippy::match_single_binding)]
249                #[allow(clippy::reversed_empty_ranges)]
250                #[allow(clippy::single_match)]
251                fn visit_key<__E>(
252                    self,
253                    __value: &str,
254                ) -> core::result::Result<Self::Value, __E>
255                where
256                    __E: _serde::de::Error,
257                {
258                    match __value {
259                        "attributeDefaults" => Ok(__Field::m_attributeDefaults),
260                        "variableInfos" => Ok(__Field::m_variableInfos),
261                        "characterPropertyInfos" => Ok(__Field::m_characterPropertyInfos),
262                        "eventInfos" => Ok(__Field::m_eventInfos),
263                        "wordMinVariableValues" => Ok(__Field::m_wordMinVariableValues),
264                        "wordMaxVariableValues" => Ok(__Field::m_wordMaxVariableValues),
265                        "variableInitialValues" => Ok(__Field::m_variableInitialValues),
266                        "stringData" => Ok(__Field::m_stringData),
267                        _ => Ok(__Field::__ignore),
268                    }
269                }
270            }
271            impl<'de> _serde::Deserialize<'de> for __Field {
272                #[inline]
273                fn deserialize<__D>(
274                    __deserializer: __D,
275                ) -> core::result::Result<Self, __D::Error>
276                where
277                    __D: _serde::Deserializer<'de>,
278                {
279                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
280                }
281            }
282            struct __hkbBehaviorGraphDataVisitor<'de> {
283                marker: _serde::__private::PhantomData<hkbBehaviorGraphData>,
284                lifetime: _serde::__private::PhantomData<&'de ()>,
285            }
286            #[allow(clippy::match_single_binding)]
287            #[allow(clippy::reversed_empty_ranges)]
288            #[allow(clippy::single_match)]
289            impl<'de> _serde::de::Visitor<'de> for __hkbBehaviorGraphDataVisitor<'de> {
290                type Value = hkbBehaviorGraphData;
291                fn expecting(
292                    &self,
293                    __formatter: &mut core::fmt::Formatter,
294                ) -> core::fmt::Result {
295                    core::fmt::Formatter::write_str(
296                        __formatter,
297                        "struct hkbBehaviorGraphData",
298                    )
299                }
300                fn visit_struct_for_bytes<__A>(
301                    self,
302                    mut __map: __A,
303                ) -> _serde::__private::Result<Self::Value, __A::Error>
304                where
305                    __A: _serde::de::MapAccess<'de>,
306                {
307                    let __ptr = __A::class_ptr(&mut __map);
308                    let parent = __A::parent_value(&mut __map)?;
309                    let mut m_attributeDefaults: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
310                    let mut m_variableInfos: _serde::__private::Option<
311                        Vec<hkbVariableInfo>,
312                    > = _serde::__private::None;
313                    let mut m_characterPropertyInfos: _serde::__private::Option<
314                        Vec<hkbVariableInfo>,
315                    > = _serde::__private::None;
316                    let mut m_eventInfos: _serde::__private::Option<Vec<hkbEventInfo>> = _serde::__private::None;
317                    let mut m_wordMinVariableValues: _serde::__private::Option<
318                        Vec<hkbVariableValue>,
319                    > = _serde::__private::None;
320                    let mut m_wordMaxVariableValues: _serde::__private::Option<
321                        Vec<hkbVariableValue>,
322                    > = _serde::__private::None;
323                    let mut m_variableInitialValues: _serde::__private::Option<
324                        Pointer,
325                    > = _serde::__private::None;
326                    let mut m_stringData: _serde::__private::Option<Pointer> = _serde::__private::None;
327                    for i in 0..8usize {
328                        match i {
329                            0usize => {
330                                if _serde::__private::Option::is_some(
331                                    &m_attributeDefaults,
332                                ) {
333                                    return _serde::__private::Err(
334                                        <__A::Error as _serde::de::Error>::duplicate_field(
335                                            "attributeDefaults",
336                                        ),
337                                    );
338                                }
339                                m_attributeDefaults = _serde::__private::Some(
340                                    match __A::next_value::<Vec<f32>>(&mut __map) {
341                                        _serde::__private::Ok(__val) => __val,
342                                        _serde::__private::Err(__err) => {
343                                            return _serde::__private::Err(__err);
344                                        }
345                                    },
346                                );
347                            }
348                            1usize => {
349                                if _serde::__private::Option::is_some(&m_variableInfos) {
350                                    return _serde::__private::Err(
351                                        <__A::Error as _serde::de::Error>::duplicate_field(
352                                            "variableInfos",
353                                        ),
354                                    );
355                                }
356                                m_variableInfos = _serde::__private::Some(
357                                    match __A::next_value::<Vec<hkbVariableInfo>>(&mut __map) {
358                                        _serde::__private::Ok(__val) => __val,
359                                        _serde::__private::Err(__err) => {
360                                            return _serde::__private::Err(__err);
361                                        }
362                                    },
363                                );
364                            }
365                            2usize => {
366                                if _serde::__private::Option::is_some(
367                                    &m_characterPropertyInfos,
368                                ) {
369                                    return _serde::__private::Err(
370                                        <__A::Error as _serde::de::Error>::duplicate_field(
371                                            "characterPropertyInfos",
372                                        ),
373                                    );
374                                }
375                                m_characterPropertyInfos = _serde::__private::Some(
376                                    match __A::next_value::<Vec<hkbVariableInfo>>(&mut __map) {
377                                        _serde::__private::Ok(__val) => __val,
378                                        _serde::__private::Err(__err) => {
379                                            return _serde::__private::Err(__err);
380                                        }
381                                    },
382                                );
383                            }
384                            3usize => {
385                                if _serde::__private::Option::is_some(&m_eventInfos) {
386                                    return _serde::__private::Err(
387                                        <__A::Error as _serde::de::Error>::duplicate_field(
388                                            "eventInfos",
389                                        ),
390                                    );
391                                }
392                                m_eventInfos = _serde::__private::Some(
393                                    match __A::next_value::<Vec<hkbEventInfo>>(&mut __map) {
394                                        _serde::__private::Ok(__val) => __val,
395                                        _serde::__private::Err(__err) => {
396                                            return _serde::__private::Err(__err);
397                                        }
398                                    },
399                                );
400                            }
401                            4usize => {
402                                if _serde::__private::Option::is_some(
403                                    &m_wordMinVariableValues,
404                                ) {
405                                    return _serde::__private::Err(
406                                        <__A::Error as _serde::de::Error>::duplicate_field(
407                                            "wordMinVariableValues",
408                                        ),
409                                    );
410                                }
411                                m_wordMinVariableValues = _serde::__private::Some(
412                                    match __A::next_value::<Vec<hkbVariableValue>>(&mut __map) {
413                                        _serde::__private::Ok(__val) => __val,
414                                        _serde::__private::Err(__err) => {
415                                            return _serde::__private::Err(__err);
416                                        }
417                                    },
418                                );
419                            }
420                            5usize => {
421                                if _serde::__private::Option::is_some(
422                                    &m_wordMaxVariableValues,
423                                ) {
424                                    return _serde::__private::Err(
425                                        <__A::Error as _serde::de::Error>::duplicate_field(
426                                            "wordMaxVariableValues",
427                                        ),
428                                    );
429                                }
430                                m_wordMaxVariableValues = _serde::__private::Some(
431                                    match __A::next_value::<Vec<hkbVariableValue>>(&mut __map) {
432                                        _serde::__private::Ok(__val) => __val,
433                                        _serde::__private::Err(__err) => {
434                                            return _serde::__private::Err(__err);
435                                        }
436                                    },
437                                );
438                            }
439                            6usize => {
440                                if _serde::__private::Option::is_some(
441                                    &m_variableInitialValues,
442                                ) {
443                                    return _serde::__private::Err(
444                                        <__A::Error as _serde::de::Error>::duplicate_field(
445                                            "variableInitialValues",
446                                        ),
447                                    );
448                                }
449                                m_variableInitialValues = _serde::__private::Some(
450                                    match __A::next_value::<Pointer>(&mut __map) {
451                                        _serde::__private::Ok(__val) => __val,
452                                        _serde::__private::Err(__err) => {
453                                            return _serde::__private::Err(__err);
454                                        }
455                                    },
456                                );
457                            }
458                            7usize => {
459                                if _serde::__private::Option::is_some(&m_stringData) {
460                                    return _serde::__private::Err(
461                                        <__A::Error as _serde::de::Error>::duplicate_field(
462                                            "stringData",
463                                        ),
464                                    );
465                                }
466                                m_stringData = _serde::__private::Some(
467                                    match __A::next_value::<Pointer>(&mut __map) {
468                                        _serde::__private::Ok(__val) => __val,
469                                        _serde::__private::Err(__err) => {
470                                            return _serde::__private::Err(__err);
471                                        }
472                                    },
473                                );
474                            }
475                            _ => {}
476                        }
477                    }
478                    let m_attributeDefaults = match m_attributeDefaults {
479                        _serde::__private::Some(__field) => __field,
480                        _serde::__private::None => {
481                            return _serde::__private::Err(
482                                <__A::Error as _serde::de::Error>::missing_field(
483                                    "attributeDefaults",
484                                ),
485                            );
486                        }
487                    };
488                    let m_variableInfos = match m_variableInfos {
489                        _serde::__private::Some(__field) => __field,
490                        _serde::__private::None => {
491                            return _serde::__private::Err(
492                                <__A::Error as _serde::de::Error>::missing_field(
493                                    "variableInfos",
494                                ),
495                            );
496                        }
497                    };
498                    let m_characterPropertyInfos = match m_characterPropertyInfos {
499                        _serde::__private::Some(__field) => __field,
500                        _serde::__private::None => {
501                            return _serde::__private::Err(
502                                <__A::Error as _serde::de::Error>::missing_field(
503                                    "characterPropertyInfos",
504                                ),
505                            );
506                        }
507                    };
508                    let m_eventInfos = match m_eventInfos {
509                        _serde::__private::Some(__field) => __field,
510                        _serde::__private::None => {
511                            return _serde::__private::Err(
512                                <__A::Error as _serde::de::Error>::missing_field(
513                                    "eventInfos",
514                                ),
515                            );
516                        }
517                    };
518                    let m_wordMinVariableValues = match m_wordMinVariableValues {
519                        _serde::__private::Some(__field) => __field,
520                        _serde::__private::None => {
521                            return _serde::__private::Err(
522                                <__A::Error as _serde::de::Error>::missing_field(
523                                    "wordMinVariableValues",
524                                ),
525                            );
526                        }
527                    };
528                    let m_wordMaxVariableValues = match m_wordMaxVariableValues {
529                        _serde::__private::Some(__field) => __field,
530                        _serde::__private::None => {
531                            return _serde::__private::Err(
532                                <__A::Error as _serde::de::Error>::missing_field(
533                                    "wordMaxVariableValues",
534                                ),
535                            );
536                        }
537                    };
538                    let m_variableInitialValues = match m_variableInitialValues {
539                        _serde::__private::Some(__field) => __field,
540                        _serde::__private::None => {
541                            return _serde::__private::Err(
542                                <__A::Error as _serde::de::Error>::missing_field(
543                                    "variableInitialValues",
544                                ),
545                            );
546                        }
547                    };
548                    let m_stringData = match m_stringData {
549                        _serde::__private::Some(__field) => __field,
550                        _serde::__private::None => {
551                            return _serde::__private::Err(
552                                <__A::Error as _serde::de::Error>::missing_field(
553                                    "stringData",
554                                ),
555                            );
556                        }
557                    };
558                    _serde::__private::Ok(hkbBehaviorGraphData {
559                        __ptr,
560                        parent,
561                        m_attributeDefaults,
562                        m_variableInfos,
563                        m_characterPropertyInfos,
564                        m_eventInfos,
565                        m_wordMinVariableValues,
566                        m_wordMaxVariableValues,
567                        m_variableInitialValues,
568                        m_stringData,
569                    })
570                }
571                #[allow(clippy::manual_unwrap_or_default)]
572                fn visit_struct<__A>(
573                    self,
574                    mut __map: __A,
575                ) -> _serde::__private::Result<Self::Value, __A::Error>
576                where
577                    __A: _serde::de::MapAccess<'de>,
578                {
579                    let mut m_attributeDefaults: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
580                    let mut m_variableInfos: _serde::__private::Option<
581                        Vec<hkbVariableInfo>,
582                    > = _serde::__private::None;
583                    let mut m_characterPropertyInfos: _serde::__private::Option<
584                        Vec<hkbVariableInfo>,
585                    > = _serde::__private::None;
586                    let mut m_eventInfos: _serde::__private::Option<Vec<hkbEventInfo>> = _serde::__private::None;
587                    let mut m_wordMinVariableValues: _serde::__private::Option<
588                        Vec<hkbVariableValue>,
589                    > = _serde::__private::None;
590                    let mut m_wordMaxVariableValues: _serde::__private::Option<
591                        Vec<hkbVariableValue>,
592                    > = _serde::__private::None;
593                    let mut m_variableInitialValues: _serde::__private::Option<
594                        Pointer,
595                    > = _serde::__private::None;
596                    let mut m_stringData: _serde::__private::Option<Pointer> = _serde::__private::None;
597                    while let _serde::__private::Some(__key) = {
598                        __A::next_key::<__Field>(&mut __map)?
599                    } {
600                        match __key {
601                            __Field::m_attributeDefaults => {
602                                #[cfg(
603                                    any(feature = "strict", feature = "ignore_duplicates")
604                                )]
605                                if _serde::__private::Option::is_some(
606                                    &m_attributeDefaults,
607                                ) {
608                                    #[cfg(feature = "ignore_duplicates")]
609                                    {
610                                        __A::skip_value(&mut __map)?;
611                                        continue;
612                                    }
613                                    #[cfg(feature = "strict")]
614                                    return _serde::__private::Err(
615                                        <__A::Error as _serde::de::Error>::duplicate_field(
616                                            "attributeDefaults",
617                                        ),
618                                    );
619                                }
620                                m_attributeDefaults = _serde::__private::Some(
621                                    match __A::next_value::<Vec<f32>>(&mut __map) {
622                                        _serde::__private::Ok(__val) => __val,
623                                        _serde::__private::Err(__err) => {
624                                            return _serde::__private::Err(__err);
625                                        }
626                                    },
627                                );
628                            }
629                            __Field::m_variableInfos => {
630                                #[cfg(
631                                    any(feature = "strict", feature = "ignore_duplicates")
632                                )]
633                                if _serde::__private::Option::is_some(&m_variableInfos) {
634                                    #[cfg(feature = "ignore_duplicates")]
635                                    {
636                                        __A::skip_value(&mut __map)?;
637                                        continue;
638                                    }
639                                    #[cfg(feature = "strict")]
640                                    return _serde::__private::Err(
641                                        <__A::Error as _serde::de::Error>::duplicate_field(
642                                            "variableInfos",
643                                        ),
644                                    );
645                                }
646                                m_variableInfos = _serde::__private::Some(
647                                    match __A::next_value::<Vec<hkbVariableInfo>>(&mut __map) {
648                                        _serde::__private::Ok(__val) => __val,
649                                        _serde::__private::Err(__err) => {
650                                            return _serde::__private::Err(__err);
651                                        }
652                                    },
653                                );
654                            }
655                            __Field::m_characterPropertyInfos => {
656                                #[cfg(
657                                    any(feature = "strict", feature = "ignore_duplicates")
658                                )]
659                                if _serde::__private::Option::is_some(
660                                    &m_characterPropertyInfos,
661                                ) {
662                                    #[cfg(feature = "ignore_duplicates")]
663                                    {
664                                        __A::skip_value(&mut __map)?;
665                                        continue;
666                                    }
667                                    #[cfg(feature = "strict")]
668                                    return _serde::__private::Err(
669                                        <__A::Error as _serde::de::Error>::duplicate_field(
670                                            "characterPropertyInfos",
671                                        ),
672                                    );
673                                }
674                                m_characterPropertyInfos = _serde::__private::Some(
675                                    match __A::next_value::<Vec<hkbVariableInfo>>(&mut __map) {
676                                        _serde::__private::Ok(__val) => __val,
677                                        _serde::__private::Err(__err) => {
678                                            return _serde::__private::Err(__err);
679                                        }
680                                    },
681                                );
682                            }
683                            __Field::m_eventInfos => {
684                                #[cfg(
685                                    any(feature = "strict", feature = "ignore_duplicates")
686                                )]
687                                if _serde::__private::Option::is_some(&m_eventInfos) {
688                                    #[cfg(feature = "ignore_duplicates")]
689                                    {
690                                        __A::skip_value(&mut __map)?;
691                                        continue;
692                                    }
693                                    #[cfg(feature = "strict")]
694                                    return _serde::__private::Err(
695                                        <__A::Error as _serde::de::Error>::duplicate_field(
696                                            "eventInfos",
697                                        ),
698                                    );
699                                }
700                                m_eventInfos = _serde::__private::Some(
701                                    match __A::next_value::<Vec<hkbEventInfo>>(&mut __map) {
702                                        _serde::__private::Ok(__val) => __val,
703                                        _serde::__private::Err(__err) => {
704                                            return _serde::__private::Err(__err);
705                                        }
706                                    },
707                                );
708                            }
709                            __Field::m_wordMinVariableValues => {
710                                #[cfg(
711                                    any(feature = "strict", feature = "ignore_duplicates")
712                                )]
713                                if _serde::__private::Option::is_some(
714                                    &m_wordMinVariableValues,
715                                ) {
716                                    #[cfg(feature = "ignore_duplicates")]
717                                    {
718                                        __A::skip_value(&mut __map)?;
719                                        continue;
720                                    }
721                                    #[cfg(feature = "strict")]
722                                    return _serde::__private::Err(
723                                        <__A::Error as _serde::de::Error>::duplicate_field(
724                                            "wordMinVariableValues",
725                                        ),
726                                    );
727                                }
728                                m_wordMinVariableValues = _serde::__private::Some(
729                                    match __A::next_value::<Vec<hkbVariableValue>>(&mut __map) {
730                                        _serde::__private::Ok(__val) => __val,
731                                        _serde::__private::Err(__err) => {
732                                            return _serde::__private::Err(__err);
733                                        }
734                                    },
735                                );
736                            }
737                            __Field::m_wordMaxVariableValues => {
738                                #[cfg(
739                                    any(feature = "strict", feature = "ignore_duplicates")
740                                )]
741                                if _serde::__private::Option::is_some(
742                                    &m_wordMaxVariableValues,
743                                ) {
744                                    #[cfg(feature = "ignore_duplicates")]
745                                    {
746                                        __A::skip_value(&mut __map)?;
747                                        continue;
748                                    }
749                                    #[cfg(feature = "strict")]
750                                    return _serde::__private::Err(
751                                        <__A::Error as _serde::de::Error>::duplicate_field(
752                                            "wordMaxVariableValues",
753                                        ),
754                                    );
755                                }
756                                m_wordMaxVariableValues = _serde::__private::Some(
757                                    match __A::next_value::<Vec<hkbVariableValue>>(&mut __map) {
758                                        _serde::__private::Ok(__val) => __val,
759                                        _serde::__private::Err(__err) => {
760                                            return _serde::__private::Err(__err);
761                                        }
762                                    },
763                                );
764                            }
765                            __Field::m_variableInitialValues => {
766                                #[cfg(
767                                    any(feature = "strict", feature = "ignore_duplicates")
768                                )]
769                                if _serde::__private::Option::is_some(
770                                    &m_variableInitialValues,
771                                ) {
772                                    #[cfg(feature = "ignore_duplicates")]
773                                    {
774                                        __A::skip_value(&mut __map)?;
775                                        continue;
776                                    }
777                                    #[cfg(feature = "strict")]
778                                    return _serde::__private::Err(
779                                        <__A::Error as _serde::de::Error>::duplicate_field(
780                                            "variableInitialValues",
781                                        ),
782                                    );
783                                }
784                                m_variableInitialValues = _serde::__private::Some(
785                                    match __A::next_value::<Pointer>(&mut __map) {
786                                        _serde::__private::Ok(__val) => __val,
787                                        _serde::__private::Err(__err) => {
788                                            return _serde::__private::Err(__err);
789                                        }
790                                    },
791                                );
792                            }
793                            __Field::m_stringData => {
794                                #[cfg(
795                                    any(feature = "strict", feature = "ignore_duplicates")
796                                )]
797                                if _serde::__private::Option::is_some(&m_stringData) {
798                                    #[cfg(feature = "ignore_duplicates")]
799                                    {
800                                        __A::skip_value(&mut __map)?;
801                                        continue;
802                                    }
803                                    #[cfg(feature = "strict")]
804                                    return _serde::__private::Err(
805                                        <__A::Error as _serde::de::Error>::duplicate_field(
806                                            "stringData",
807                                        ),
808                                    );
809                                }
810                                m_stringData = _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                            _ => __A::skip_value(&mut __map)?,
820                        }
821                    }
822                    let m_attributeDefaults = match m_attributeDefaults {
823                        _serde::__private::Some(__field) => __field,
824                        _serde::__private::None => {
825                            #[cfg(feature = "strict")]
826                            return _serde::__private::Err(
827                                <__A::Error as _serde::de::Error>::missing_field(
828                                    "attributeDefaults",
829                                ),
830                            );
831                            #[cfg(not(feature = "strict"))] Default::default()
832                        }
833                    };
834                    let m_variableInfos = match m_variableInfos {
835                        _serde::__private::Some(__field) => __field,
836                        _serde::__private::None => {
837                            #[cfg(feature = "strict")]
838                            return _serde::__private::Err(
839                                <__A::Error as _serde::de::Error>::missing_field(
840                                    "variableInfos",
841                                ),
842                            );
843                            #[cfg(not(feature = "strict"))] Default::default()
844                        }
845                    };
846                    let m_characterPropertyInfos = match m_characterPropertyInfos {
847                        _serde::__private::Some(__field) => __field,
848                        _serde::__private::None => {
849                            #[cfg(feature = "strict")]
850                            return _serde::__private::Err(
851                                <__A::Error as _serde::de::Error>::missing_field(
852                                    "characterPropertyInfos",
853                                ),
854                            );
855                            #[cfg(not(feature = "strict"))] Default::default()
856                        }
857                    };
858                    let m_eventInfos = match m_eventInfos {
859                        _serde::__private::Some(__field) => __field,
860                        _serde::__private::None => {
861                            #[cfg(feature = "strict")]
862                            return _serde::__private::Err(
863                                <__A::Error as _serde::de::Error>::missing_field(
864                                    "eventInfos",
865                                ),
866                            );
867                            #[cfg(not(feature = "strict"))] Default::default()
868                        }
869                    };
870                    let m_wordMinVariableValues = match m_wordMinVariableValues {
871                        _serde::__private::Some(__field) => __field,
872                        _serde::__private::None => {
873                            #[cfg(feature = "strict")]
874                            return _serde::__private::Err(
875                                <__A::Error as _serde::de::Error>::missing_field(
876                                    "wordMinVariableValues",
877                                ),
878                            );
879                            #[cfg(not(feature = "strict"))] Default::default()
880                        }
881                    };
882                    let m_wordMaxVariableValues = match m_wordMaxVariableValues {
883                        _serde::__private::Some(__field) => __field,
884                        _serde::__private::None => {
885                            #[cfg(feature = "strict")]
886                            return _serde::__private::Err(
887                                <__A::Error as _serde::de::Error>::missing_field(
888                                    "wordMaxVariableValues",
889                                ),
890                            );
891                            #[cfg(not(feature = "strict"))] Default::default()
892                        }
893                    };
894                    let m_variableInitialValues = match m_variableInitialValues {
895                        _serde::__private::Some(__field) => __field,
896                        _serde::__private::None => {
897                            #[cfg(feature = "strict")]
898                            return _serde::__private::Err(
899                                <__A::Error as _serde::de::Error>::missing_field(
900                                    "variableInitialValues",
901                                ),
902                            );
903                            #[cfg(not(feature = "strict"))] Default::default()
904                        }
905                    };
906                    let m_stringData = match m_stringData {
907                        _serde::__private::Some(__field) => __field,
908                        _serde::__private::None => {
909                            #[cfg(feature = "strict")]
910                            return _serde::__private::Err(
911                                <__A::Error as _serde::de::Error>::missing_field(
912                                    "stringData",
913                                ),
914                            );
915                            #[cfg(not(feature = "strict"))] Default::default()
916                        }
917                    };
918                    let __ptr = None;
919                    let parent = hkBaseObject { __ptr };
920                    let parent = hkReferencedObject {
921                        __ptr,
922                        parent,
923                        ..Default::default()
924                    };
925                    let __ptr = __A::class_ptr(&mut __map);
926                    _serde::__private::Ok(hkbBehaviorGraphData {
927                        __ptr,
928                        parent,
929                        m_attributeDefaults,
930                        m_variableInfos,
931                        m_characterPropertyInfos,
932                        m_eventInfos,
933                        m_wordMinVariableValues,
934                        m_wordMaxVariableValues,
935                        m_variableInitialValues,
936                        m_stringData,
937                    })
938                }
939            }
940            const FIELDS: &[&str] = &[
941                "attributeDefaults",
942                "variableInfos",
943                "characterPropertyInfos",
944                "eventInfos",
945                "wordMinVariableValues",
946                "wordMaxVariableValues",
947                "variableInitialValues",
948                "stringData",
949            ];
950            _serde::Deserializer::deserialize_struct(
951                deserializer,
952                "hkbBehaviorGraphData",
953                FIELDS,
954                __hkbBehaviorGraphDataVisitor {
955                    marker: _serde::__private::PhantomData::<hkbBehaviorGraphData>,
956                    lifetime: _serde::__private::PhantomData,
957                },
958            )
959        }
960    }
961};