havok_classes/generated/
hkbSequenceInternalState_.rs

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

havok_classes/generated/
hkbSequenceInternalState_.rs
