havok_classes/generated/
hkbTimerModifier_.rs

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