havok_classes/generated/
hkbStateMachineDelayedTransitionInfo_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbStateMachineDelayedTransitionInfo`
5/// - version: `1`
6/// - signature: `0x26d5499`
7/// - size: ` 24`(x86)/` 24`(x86_64)
8/// -  vtable: `false`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkbStateMachineDelayedTransitionInfo {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// # C++ Info
27    /// - name: `delayedTransition`(ctype: `struct hkbStateMachineProspectiveTransitionInfo`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 16`(x86)/` 16`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "delayedTransition"))]
31    #[cfg_attr(feature = "serde", serde(rename = "delayedTransition"))]
32    pub m_delayedTransition: hkbStateMachineProspectiveTransitionInfo,
33    /// # C++ Info
34    /// - name: `timeDelayed`(ctype: `hkReal`)
35    /// - offset: ` 16`(x86)/` 16`(x86_64)
36    /// - type_size: `  4`(x86)/`  4`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "timeDelayed"))]
38    #[cfg_attr(feature = "serde", serde(rename = "timeDelayed"))]
39    pub m_timeDelayed: f32,
40    /// # C++ Info
41    /// - name: `isDelayedTransitionReturnToPreviousState`(ctype: `hkBool`)
42    /// - offset: ` 20`(x86)/` 20`(x86_64)
43    /// - type_size: `  1`(x86)/`  1`(x86_64)
44    #[cfg_attr(
45        feature = "json_schema",
46        schemars(rename = "isDelayedTransitionReturnToPreviousState")
47    )]
48    #[cfg_attr(
49        feature = "serde",
50        serde(rename = "isDelayedTransitionReturnToPreviousState")
51    )]
52    pub m_isDelayedTransitionReturnToPreviousState: bool,
53    /// # C++ Info
54    /// - name: `wasInAbutRangeLastFrame`(ctype: `hkBool`)
55    /// - offset: ` 21`(x86)/` 21`(x86_64)
56    /// - type_size: `  1`(x86)/`  1`(x86_64)
57    #[cfg_attr(feature = "json_schema", schemars(rename = "wasInAbutRangeLastFrame"))]
58    #[cfg_attr(feature = "serde", serde(rename = "wasInAbutRangeLastFrame"))]
59    pub m_wasInAbutRangeLastFrame: bool,
60}
61const _: () = {
62    use havok_serde as _serde;
63    impl _serde::HavokClass for hkbStateMachineDelayedTransitionInfo {
64        #[inline]
65        fn name(&self) -> &'static str {
66            "hkbStateMachineDelayedTransitionInfo"
67        }
68        #[inline]
69        fn signature(&self) -> _serde::__private::Signature {
70            _serde::__private::Signature::new(0x26d5499)
71        }
72        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
73        fn deps_indexes(&self) -> Vec<usize> {
74            let mut v = Vec::new();
75            v.extend(self.m_delayedTransition.deps_indexes());
76            v
77        }
78    }
79    impl _serde::Serialize for hkbStateMachineDelayedTransitionInfo {
80        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
81        where
82            S: _serde::ser::Serializer,
83        {
84            let class_meta = self
85                .__ptr
86                .map(|name| (name, _serde::__private::Signature::new(0x26d5499)));
87            let mut serializer = __serializer
88                .serialize_struct(
89                    "hkbStateMachineDelayedTransitionInfo",
90                    class_meta,
91                    (24u64, 24u64),
92                )?;
93            serializer.serialize_field("delayedTransition", &self.m_delayedTransition)?;
94            serializer.serialize_field("timeDelayed", &self.m_timeDelayed)?;
95            serializer
96                .serialize_field(
97                    "isDelayedTransitionReturnToPreviousState",
98                    &self.m_isDelayedTransitionReturnToPreviousState,
99                )?;
100            serializer
101                .serialize_field(
102                    "wasInAbutRangeLastFrame",
103                    &self.m_wasInAbutRangeLastFrame,
104                )?;
105            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
106            serializer.end()
107        }
108    }
109};
110#[doc(hidden)]
111#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
112const _: () = {
113    use havok_serde as _serde;
114    #[automatically_derived]
115    impl<'de> _serde::Deserialize<'de> for hkbStateMachineDelayedTransitionInfo {
116        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
117        where
118            __D: _serde::Deserializer<'de>,
119        {
120            #[allow(non_camel_case_types)]
121            enum __Field {
122                m_delayedTransition,
123                m_timeDelayed,
124                m_isDelayedTransitionReturnToPreviousState,
125                m_wasInAbutRangeLastFrame,
126                __ignore,
127            }
128            struct __FieldVisitor;
129            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
130                type Value = __Field;
131                fn expecting(
132                    &self,
133                    __formatter: &mut core::fmt::Formatter,
134                ) -> core::fmt::Result {
135                    core::fmt::Formatter::write_str(__formatter, "field identifier")
136                }
137                /// Intended for use in XML.
138                #[allow(clippy::match_single_binding)]
139                #[allow(clippy::reversed_empty_ranges)]
140                #[allow(clippy::single_match)]
141                fn visit_key<__E>(
142                    self,
143                    __value: &str,
144                ) -> core::result::Result<Self::Value, __E>
145                where
146                    __E: _serde::de::Error,
147                {
148                    match __value {
149                        "delayedTransition" => Ok(__Field::m_delayedTransition),
150                        "timeDelayed" => Ok(__Field::m_timeDelayed),
151                        "isDelayedTransitionReturnToPreviousState" => {
152                            Ok(__Field::m_isDelayedTransitionReturnToPreviousState)
153                        }
154                        "wasInAbutRangeLastFrame" => {
155                            Ok(__Field::m_wasInAbutRangeLastFrame)
156                        }
157                        _ => Ok(__Field::__ignore),
158                    }
159                }
160            }
161            impl<'de> _serde::Deserialize<'de> for __Field {
162                #[inline]
163                fn deserialize<__D>(
164                    __deserializer: __D,
165                ) -> core::result::Result<Self, __D::Error>
166                where
167                    __D: _serde::Deserializer<'de>,
168                {
169                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
170                }
171            }
172            struct __hkbStateMachineDelayedTransitionInfoVisitor<'de> {
173                marker: _serde::__private::PhantomData<
174                    hkbStateMachineDelayedTransitionInfo,
175                >,
176                lifetime: _serde::__private::PhantomData<&'de ()>,
177            }
178            #[allow(clippy::match_single_binding)]
179            #[allow(clippy::reversed_empty_ranges)]
180            #[allow(clippy::single_match)]
181            impl<'de> _serde::de::Visitor<'de>
182            for __hkbStateMachineDelayedTransitionInfoVisitor<'de> {
183                type Value = hkbStateMachineDelayedTransitionInfo;
184                fn expecting(
185                    &self,
186                    __formatter: &mut core::fmt::Formatter,
187                ) -> core::fmt::Result {
188                    core::fmt::Formatter::write_str(
189                        __formatter,
190                        "struct hkbStateMachineDelayedTransitionInfo",
191                    )
192                }
193                fn visit_struct_for_bytes<__A>(
194                    self,
195                    mut __map: __A,
196                ) -> _serde::__private::Result<Self::Value, __A::Error>
197                where
198                    __A: _serde::de::MapAccess<'de>,
199                {
200                    let __ptr = __A::class_ptr(&mut __map);
201                    let mut m_delayedTransition: _serde::__private::Option<
202                        hkbStateMachineProspectiveTransitionInfo,
203                    > = _serde::__private::None;
204                    let mut m_timeDelayed: _serde::__private::Option<f32> = _serde::__private::None;
205                    let mut m_isDelayedTransitionReturnToPreviousState: _serde::__private::Option<
206                        bool,
207                    > = _serde::__private::None;
208                    let mut m_wasInAbutRangeLastFrame: _serde::__private::Option<bool> = _serde::__private::None;
209                    for i in 0..4usize {
210                        match i {
211                            0usize => {
212                                if _serde::__private::Option::is_some(
213                                    &m_delayedTransition,
214                                ) {
215                                    return _serde::__private::Err(
216                                        <__A::Error as _serde::de::Error>::duplicate_field(
217                                            "delayedTransition",
218                                        ),
219                                    );
220                                }
221                                m_delayedTransition = _serde::__private::Some(
222                                    match __A::next_value::<
223                                        hkbStateMachineProspectiveTransitionInfo,
224                                    >(&mut __map) {
225                                        _serde::__private::Ok(__val) => __val,
226                                        _serde::__private::Err(__err) => {
227                                            return _serde::__private::Err(__err);
228                                        }
229                                    },
230                                );
231                            }
232                            1usize => {
233                                if _serde::__private::Option::is_some(&m_timeDelayed) {
234                                    return _serde::__private::Err(
235                                        <__A::Error as _serde::de::Error>::duplicate_field(
236                                            "timeDelayed",
237                                        ),
238                                    );
239                                }
240                                m_timeDelayed = _serde::__private::Some(
241                                    match __A::next_value::<f32>(&mut __map) {
242                                        _serde::__private::Ok(__val) => __val,
243                                        _serde::__private::Err(__err) => {
244                                            return _serde::__private::Err(__err);
245                                        }
246                                    },
247                                );
248                            }
249                            2usize => {
250                                if _serde::__private::Option::is_some(
251                                    &m_isDelayedTransitionReturnToPreviousState,
252                                ) {
253                                    return _serde::__private::Err(
254                                        <__A::Error as _serde::de::Error>::duplicate_field(
255                                            "isDelayedTransitionReturnToPreviousState",
256                                        ),
257                                    );
258                                }
259                                m_isDelayedTransitionReturnToPreviousState = _serde::__private::Some(
260                                    match __A::next_value::<bool>(&mut __map) {
261                                        _serde::__private::Ok(__val) => __val,
262                                        _serde::__private::Err(__err) => {
263                                            return _serde::__private::Err(__err);
264                                        }
265                                    },
266                                );
267                            }
268                            3usize => {
269                                if _serde::__private::Option::is_some(
270                                    &m_wasInAbutRangeLastFrame,
271                                ) {
272                                    return _serde::__private::Err(
273                                        <__A::Error as _serde::de::Error>::duplicate_field(
274                                            "wasInAbutRangeLastFrame",
275                                        ),
276                                    );
277                                }
278                                m_wasInAbutRangeLastFrame = _serde::__private::Some(
279                                    match __A::next_value::<bool>(&mut __map) {
280                                        _serde::__private::Ok(__val) => __val,
281                                        _serde::__private::Err(__err) => {
282                                            return _serde::__private::Err(__err);
283                                        }
284                                    },
285                                );
286                            }
287                            _ => {}
288                        }
289                    }
290                    __A::pad(&mut __map, 2usize, 2usize)?;
291                    let m_delayedTransition = match m_delayedTransition {
292                        _serde::__private::Some(__field) => __field,
293                        _serde::__private::None => {
294                            return _serde::__private::Err(
295                                <__A::Error as _serde::de::Error>::missing_field(
296                                    "delayedTransition",
297                                ),
298                            );
299                        }
300                    };
301                    let m_timeDelayed = match m_timeDelayed {
302                        _serde::__private::Some(__field) => __field,
303                        _serde::__private::None => {
304                            return _serde::__private::Err(
305                                <__A::Error as _serde::de::Error>::missing_field(
306                                    "timeDelayed",
307                                ),
308                            );
309                        }
310                    };
311                    let m_isDelayedTransitionReturnToPreviousState = match m_isDelayedTransitionReturnToPreviousState {
312                        _serde::__private::Some(__field) => __field,
313                        _serde::__private::None => {
314                            return _serde::__private::Err(
315                                <__A::Error as _serde::de::Error>::missing_field(
316                                    "isDelayedTransitionReturnToPreviousState",
317                                ),
318                            );
319                        }
320                    };
321                    let m_wasInAbutRangeLastFrame = match m_wasInAbutRangeLastFrame {
322                        _serde::__private::Some(__field) => __field,
323                        _serde::__private::None => {
324                            return _serde::__private::Err(
325                                <__A::Error as _serde::de::Error>::missing_field(
326                                    "wasInAbutRangeLastFrame",
327                                ),
328                            );
329                        }
330                    };
331                    _serde::__private::Ok(hkbStateMachineDelayedTransitionInfo {
332                        __ptr,
333                        m_delayedTransition,
334                        m_timeDelayed,
335                        m_isDelayedTransitionReturnToPreviousState,
336                        m_wasInAbutRangeLastFrame,
337                    })
338                }
339                #[allow(clippy::manual_unwrap_or_default)]
340                fn visit_struct<__A>(
341                    self,
342                    mut __map: __A,
343                ) -> _serde::__private::Result<Self::Value, __A::Error>
344                where
345                    __A: _serde::de::MapAccess<'de>,
346                {
347                    let mut m_delayedTransition: _serde::__private::Option<
348                        hkbStateMachineProspectiveTransitionInfo,
349                    > = _serde::__private::None;
350                    let mut m_timeDelayed: _serde::__private::Option<f32> = _serde::__private::None;
351                    let mut m_isDelayedTransitionReturnToPreviousState: _serde::__private::Option<
352                        bool,
353                    > = _serde::__private::None;
354                    let mut m_wasInAbutRangeLastFrame: _serde::__private::Option<bool> = _serde::__private::None;
355                    while let _serde::__private::Some(__key) = {
356                        __A::next_key::<__Field>(&mut __map)?
357                    } {
358                        match __key {
359                            __Field::m_delayedTransition => {
360                                #[cfg(
361                                    any(feature = "strict", feature = "ignore_duplicates")
362                                )]
363                                if _serde::__private::Option::is_some(
364                                    &m_delayedTransition,
365                                ) {
366                                    #[cfg(feature = "ignore_duplicates")]
367                                    {
368                                        __A::skip_value(&mut __map)?;
369                                        continue;
370                                    }
371                                    #[cfg(feature = "strict")]
372                                    return _serde::__private::Err(
373                                        <__A::Error as _serde::de::Error>::duplicate_field(
374                                            "delayedTransition",
375                                        ),
376                                    );
377                                }
378                                m_delayedTransition = _serde::__private::Some(
379                                    match __A::next_value::<
380                                        hkbStateMachineProspectiveTransitionInfo,
381                                    >(&mut __map) {
382                                        _serde::__private::Ok(__val) => __val,
383                                        _serde::__private::Err(__err) => {
384                                            return _serde::__private::Err(__err);
385                                        }
386                                    },
387                                );
388                            }
389                            __Field::m_timeDelayed => {
390                                #[cfg(
391                                    any(feature = "strict", feature = "ignore_duplicates")
392                                )]
393                                if _serde::__private::Option::is_some(&m_timeDelayed) {
394                                    #[cfg(feature = "ignore_duplicates")]
395                                    {
396                                        __A::skip_value(&mut __map)?;
397                                        continue;
398                                    }
399                                    #[cfg(feature = "strict")]
400                                    return _serde::__private::Err(
401                                        <__A::Error as _serde::de::Error>::duplicate_field(
402                                            "timeDelayed",
403                                        ),
404                                    );
405                                }
406                                m_timeDelayed = _serde::__private::Some(
407                                    match __A::next_value::<f32>(&mut __map) {
408                                        _serde::__private::Ok(__val) => __val,
409                                        _serde::__private::Err(__err) => {
410                                            return _serde::__private::Err(__err);
411                                        }
412                                    },
413                                );
414                            }
415                            __Field::m_isDelayedTransitionReturnToPreviousState => {
416                                #[cfg(
417                                    any(feature = "strict", feature = "ignore_duplicates")
418                                )]
419                                if _serde::__private::Option::is_some(
420                                    &m_isDelayedTransitionReturnToPreviousState,
421                                ) {
422                                    #[cfg(feature = "ignore_duplicates")]
423                                    {
424                                        __A::skip_value(&mut __map)?;
425                                        continue;
426                                    }
427                                    #[cfg(feature = "strict")]
428                                    return _serde::__private::Err(
429                                        <__A::Error as _serde::de::Error>::duplicate_field(
430                                            "isDelayedTransitionReturnToPreviousState",
431                                        ),
432                                    );
433                                }
434                                m_isDelayedTransitionReturnToPreviousState = _serde::__private::Some(
435                                    match __A::next_value::<bool>(&mut __map) {
436                                        _serde::__private::Ok(__val) => __val,
437                                        _serde::__private::Err(__err) => {
438                                            return _serde::__private::Err(__err);
439                                        }
440                                    },
441                                );
442                            }
443                            __Field::m_wasInAbutRangeLastFrame => {
444                                #[cfg(
445                                    any(feature = "strict", feature = "ignore_duplicates")
446                                )]
447                                if _serde::__private::Option::is_some(
448                                    &m_wasInAbutRangeLastFrame,
449                                ) {
450                                    #[cfg(feature = "ignore_duplicates")]
451                                    {
452                                        __A::skip_value(&mut __map)?;
453                                        continue;
454                                    }
455                                    #[cfg(feature = "strict")]
456                                    return _serde::__private::Err(
457                                        <__A::Error as _serde::de::Error>::duplicate_field(
458                                            "wasInAbutRangeLastFrame",
459                                        ),
460                                    );
461                                }
462                                m_wasInAbutRangeLastFrame = _serde::__private::Some(
463                                    match __A::next_value::<bool>(&mut __map) {
464                                        _serde::__private::Ok(__val) => __val,
465                                        _serde::__private::Err(__err) => {
466                                            return _serde::__private::Err(__err);
467                                        }
468                                    },
469                                );
470                            }
471                            _ => __A::skip_value(&mut __map)?,
472                        }
473                    }
474                    let m_delayedTransition = match m_delayedTransition {
475                        _serde::__private::Some(__field) => __field,
476                        _serde::__private::None => {
477                            #[cfg(feature = "strict")]
478                            return _serde::__private::Err(
479                                <__A::Error as _serde::de::Error>::missing_field(
480                                    "delayedTransition",
481                                ),
482                            );
483                            #[cfg(not(feature = "strict"))] Default::default()
484                        }
485                    };
486                    let m_timeDelayed = match m_timeDelayed {
487                        _serde::__private::Some(__field) => __field,
488                        _serde::__private::None => {
489                            #[cfg(feature = "strict")]
490                            return _serde::__private::Err(
491                                <__A::Error as _serde::de::Error>::missing_field(
492                                    "timeDelayed",
493                                ),
494                            );
495                            #[cfg(not(feature = "strict"))] Default::default()
496                        }
497                    };
498                    let m_isDelayedTransitionReturnToPreviousState = match m_isDelayedTransitionReturnToPreviousState {
499                        _serde::__private::Some(__field) => __field,
500                        _serde::__private::None => {
501                            #[cfg(feature = "strict")]
502                            return _serde::__private::Err(
503                                <__A::Error as _serde::de::Error>::missing_field(
504                                    "isDelayedTransitionReturnToPreviousState",
505                                ),
506                            );
507                            #[cfg(not(feature = "strict"))] Default::default()
508                        }
509                    };
510                    let m_wasInAbutRangeLastFrame = match m_wasInAbutRangeLastFrame {
511                        _serde::__private::Some(__field) => __field,
512                        _serde::__private::None => {
513                            #[cfg(feature = "strict")]
514                            return _serde::__private::Err(
515                                <__A::Error as _serde::de::Error>::missing_field(
516                                    "wasInAbutRangeLastFrame",
517                                ),
518                            );
519                            #[cfg(not(feature = "strict"))] Default::default()
520                        }
521                    };
522                    let __ptr = __A::class_ptr(&mut __map);
523                    _serde::__private::Ok(hkbStateMachineDelayedTransitionInfo {
524                        __ptr,
525                        m_delayedTransition,
526                        m_timeDelayed,
527                        m_isDelayedTransitionReturnToPreviousState,
528                        m_wasInAbutRangeLastFrame,
529                    })
530                }
531            }
532            const FIELDS: &[&str] = &[
533                "delayedTransition",
534                "timeDelayed",
535                "isDelayedTransitionReturnToPreviousState",
536                "wasInAbutRangeLastFrame",
537            ];
538            _serde::Deserializer::deserialize_struct(
539                deserializer,
540                "hkbStateMachineDelayedTransitionInfo",
541                FIELDS,
542                __hkbStateMachineDelayedTransitionInfoVisitor {
543                    marker: _serde::__private::PhantomData::<
544                        hkbStateMachineDelayedTransitionInfo,
545                    >,
546                    lifetime: _serde::__private::PhantomData,
547                },
548            )
549        }
550    }
551};