havok_classes/generated/
hkbPoseMatchingGeneratorInternalState_.rs

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