havok_classes/generated/
hkbStateMachineInternalState_.rs

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