havok_classes/generated/
hkbMoveCharacterModifier_.rs

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