havok_classes/generated/
hkbDampingModifierInternalState_.rs

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

havok_classes/generated/
hkbDampingModifierInternalState_.rs
