havok_classes/generated/
hkpSpringAction_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpSpringAction`
5/// - version: `0`
6/// - signature: `0x88fc09fa`
7/// - size: ` 96`(x86)/`128`(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 hkpSpringAction<'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: hkpBinaryAction<'a>,
31    /// # C++ Info
32    /// - name: `lastForce`(ctype: `hkVector4`)
33    /// - offset: ` 32`(x86)/` 64`(x86_64)
34    /// - type_size: ` 16`(x86)/` 16`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "lastForce"))]
36    #[cfg_attr(feature = "serde", serde(rename = "lastForce"))]
37    pub m_lastForce: Vector4,
38    /// # C++ Info
39    /// - name: `positionAinA`(ctype: `hkVector4`)
40    /// - offset: ` 48`(x86)/` 80`(x86_64)
41    /// - type_size: ` 16`(x86)/` 16`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "positionAinA"))]
43    #[cfg_attr(feature = "serde", serde(rename = "positionAinA"))]
44    pub m_positionAinA: Vector4,
45    /// # C++ Info
46    /// - name: `positionBinB`(ctype: `hkVector4`)
47    /// - offset: ` 64`(x86)/` 96`(x86_64)
48    /// - type_size: ` 16`(x86)/` 16`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "positionBinB"))]
50    #[cfg_attr(feature = "serde", serde(rename = "positionBinB"))]
51    pub m_positionBinB: Vector4,
52    /// # C++ Info
53    /// - name: `restLength`(ctype: `hkReal`)
54    /// - offset: ` 80`(x86)/`112`(x86_64)
55    /// - type_size: `  4`(x86)/`  4`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "restLength"))]
57    #[cfg_attr(feature = "serde", serde(rename = "restLength"))]
58    pub m_restLength: f32,
59    /// # C++ Info
60    /// - name: `strength`(ctype: `hkReal`)
61    /// - offset: ` 84`(x86)/`116`(x86_64)
62    /// - type_size: `  4`(x86)/`  4`(x86_64)
63    #[cfg_attr(feature = "json_schema", schemars(rename = "strength"))]
64    #[cfg_attr(feature = "serde", serde(rename = "strength"))]
65    pub m_strength: f32,
66    /// # C++ Info
67    /// - name: `damping`(ctype: `hkReal`)
68    /// - offset: ` 88`(x86)/`120`(x86_64)
69    /// - type_size: `  4`(x86)/`  4`(x86_64)
70    #[cfg_attr(feature = "json_schema", schemars(rename = "damping"))]
71    #[cfg_attr(feature = "serde", serde(rename = "damping"))]
72    pub m_damping: f32,
73    /// # C++ Info
74    /// - name: `onCompression`(ctype: `hkBool`)
75    /// - offset: ` 92`(x86)/`124`(x86_64)
76    /// - type_size: `  1`(x86)/`  1`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "onCompression"))]
78    #[cfg_attr(feature = "serde", serde(rename = "onCompression"))]
79    pub m_onCompression: bool,
80    /// # C++ Info
81    /// - name: `onExtension`(ctype: `hkBool`)
82    /// - offset: ` 93`(x86)/`125`(x86_64)
83    /// - type_size: `  1`(x86)/`  1`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "onExtension"))]
85    #[cfg_attr(feature = "serde", serde(rename = "onExtension"))]
86    pub m_onExtension: bool,
87}
88const _: () = {
89    use havok_serde as _serde;
90    impl<'a> _serde::HavokClass for hkpSpringAction<'a> {
91        #[inline]
92        fn name(&self) -> &'static str {
93            "hkpSpringAction"
94        }
95        #[inline]
96        fn signature(&self) -> _serde::__private::Signature {
97            _serde::__private::Signature::new(0x88fc09fa)
98        }
99        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
100        fn deps_indexes(&self) -> Vec<usize> {
101            let mut v = Vec::new();
102            v.push(self.parent.parent.m_world.get());
103            v.push(self.parent.parent.m_island.get());
104            v.push(self.parent.m_entityA.get());
105            v.push(self.parent.m_entityB.get());
106            v
107        }
108    }
109    impl<'a> _serde::Serialize for hkpSpringAction<'a> {
110        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
111        where
112            S: _serde::ser::Serializer,
113        {
114            let class_meta = self
115                .__ptr
116                .map(|name| (name, _serde::__private::Signature::new(0x88fc09fa)));
117            let mut serializer = __serializer
118                .serialize_struct("hkpSpringAction", class_meta, (96u64, 128u64))?;
119            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
120            serializer
121                .skip_field(
122                    "memSizeAndFlags",
123                    &self.parent.parent.parent.m_memSizeAndFlags,
124                )?;
125            serializer
126                .skip_field(
127                    "referenceCount",
128                    &self.parent.parent.parent.m_referenceCount,
129                )?;
130            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
131            serializer.skip_field("world", &self.parent.parent.m_world)?;
132            serializer.skip_field("island", &self.parent.parent.m_island)?;
133            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
134            serializer.serialize_field("name", &self.parent.parent.m_name)?;
135            serializer.serialize_field("entityA", &self.parent.m_entityA)?;
136            serializer.serialize_field("entityB", &self.parent.m_entityB)?;
137            serializer.serialize_field("lastForce", &self.m_lastForce)?;
138            serializer.serialize_field("positionAinA", &self.m_positionAinA)?;
139            serializer.serialize_field("positionBinB", &self.m_positionBinB)?;
140            serializer.serialize_field("restLength", &self.m_restLength)?;
141            serializer.serialize_field("strength", &self.m_strength)?;
142            serializer.serialize_field("damping", &self.m_damping)?;
143            serializer.serialize_field("onCompression", &self.m_onCompression)?;
144            serializer.serialize_field("onExtension", &self.m_onExtension)?;
145            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
146            serializer.end()
147        }
148    }
149};
150#[doc(hidden)]
151#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
152const _: () = {
153    use havok_serde as _serde;
154    #[automatically_derived]
155    impl<'de> _serde::Deserialize<'de> for hkpSpringAction<'de> {
156        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
157        where
158            __D: _serde::Deserializer<'de>,
159        {
160            #[allow(non_camel_case_types)]
161            enum __Field {
162                m_userData,
163                m_name,
164                m_entityA,
165                m_entityB,
166                m_lastForce,
167                m_positionAinA,
168                m_positionBinB,
169                m_restLength,
170                m_strength,
171                m_damping,
172                m_onCompression,
173                m_onExtension,
174                __ignore,
175            }
176            struct __FieldVisitor;
177            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
178                type Value = __Field;
179                fn expecting(
180                    &self,
181                    __formatter: &mut core::fmt::Formatter,
182                ) -> core::fmt::Result {
183                    core::fmt::Formatter::write_str(__formatter, "field identifier")
184                }
185                /// Intended for use in XML.
186                #[allow(clippy::match_single_binding)]
187                #[allow(clippy::reversed_empty_ranges)]
188                #[allow(clippy::single_match)]
189                fn visit_key<__E>(
190                    self,
191                    __value: &str,
192                ) -> core::result::Result<Self::Value, __E>
193                where
194                    __E: _serde::de::Error,
195                {
196                    match __value {
197                        "userData" => Ok(__Field::m_userData),
198                        "name" => Ok(__Field::m_name),
199                        "entityA" => Ok(__Field::m_entityA),
200                        "entityB" => Ok(__Field::m_entityB),
201                        "lastForce" => Ok(__Field::m_lastForce),
202                        "positionAinA" => Ok(__Field::m_positionAinA),
203                        "positionBinB" => Ok(__Field::m_positionBinB),
204                        "restLength" => Ok(__Field::m_restLength),
205                        "strength" => Ok(__Field::m_strength),
206                        "damping" => Ok(__Field::m_damping),
207                        "onCompression" => Ok(__Field::m_onCompression),
208                        "onExtension" => Ok(__Field::m_onExtension),
209                        _ => Ok(__Field::__ignore),
210                    }
211                }
212            }
213            impl<'de> _serde::Deserialize<'de> for __Field {
214                #[inline]
215                fn deserialize<__D>(
216                    __deserializer: __D,
217                ) -> core::result::Result<Self, __D::Error>
218                where
219                    __D: _serde::Deserializer<'de>,
220                {
221                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
222                }
223            }
224            struct __hkpSpringActionVisitor<'de> {
225                marker: _serde::__private::PhantomData<hkpSpringAction<'de>>,
226                lifetime: _serde::__private::PhantomData<&'de ()>,
227            }
228            #[allow(clippy::match_single_binding)]
229            #[allow(clippy::reversed_empty_ranges)]
230            #[allow(clippy::single_match)]
231            impl<'de> _serde::de::Visitor<'de> for __hkpSpringActionVisitor<'de> {
232                type Value = hkpSpringAction<'de>;
233                fn expecting(
234                    &self,
235                    __formatter: &mut core::fmt::Formatter,
236                ) -> core::fmt::Result {
237                    core::fmt::Formatter::write_str(
238                        __formatter,
239                        "struct hkpSpringAction",
240                    )
241                }
242                fn visit_struct_for_bytes<__A>(
243                    self,
244                    mut __map: __A,
245                ) -> _serde::__private::Result<Self::Value, __A::Error>
246                where
247                    __A: _serde::de::MapAccess<'de>,
248                {
249                    let __ptr = __A::class_ptr(&mut __map);
250                    let parent = __A::parent_value(&mut __map)?;
251                    let mut m_lastForce: _serde::__private::Option<Vector4> = _serde::__private::None;
252                    let mut m_positionAinA: _serde::__private::Option<Vector4> = _serde::__private::None;
253                    let mut m_positionBinB: _serde::__private::Option<Vector4> = _serde::__private::None;
254                    let mut m_restLength: _serde::__private::Option<f32> = _serde::__private::None;
255                    let mut m_strength: _serde::__private::Option<f32> = _serde::__private::None;
256                    let mut m_damping: _serde::__private::Option<f32> = _serde::__private::None;
257                    let mut m_onCompression: _serde::__private::Option<bool> = _serde::__private::None;
258                    let mut m_onExtension: _serde::__private::Option<bool> = _serde::__private::None;
259                    for i in 0..8usize {
260                        match i {
261                            0usize => {
262                                if _serde::__private::Option::is_some(&m_lastForce) {
263                                    return _serde::__private::Err(
264                                        <__A::Error as _serde::de::Error>::duplicate_field(
265                                            "lastForce",
266                                        ),
267                                    );
268                                }
269                                m_lastForce = _serde::__private::Some(
270                                    match __A::next_value::<Vector4>(&mut __map) {
271                                        _serde::__private::Ok(__val) => __val,
272                                        _serde::__private::Err(__err) => {
273                                            return _serde::__private::Err(__err);
274                                        }
275                                    },
276                                );
277                            }
278                            1usize => {
279                                if _serde::__private::Option::is_some(&m_positionAinA) {
280                                    return _serde::__private::Err(
281                                        <__A::Error as _serde::de::Error>::duplicate_field(
282                                            "positionAinA",
283                                        ),
284                                    );
285                                }
286                                m_positionAinA = _serde::__private::Some(
287                                    match __A::next_value::<Vector4>(&mut __map) {
288                                        _serde::__private::Ok(__val) => __val,
289                                        _serde::__private::Err(__err) => {
290                                            return _serde::__private::Err(__err);
291                                        }
292                                    },
293                                );
294                            }
295                            2usize => {
296                                if _serde::__private::Option::is_some(&m_positionBinB) {
297                                    return _serde::__private::Err(
298                                        <__A::Error as _serde::de::Error>::duplicate_field(
299                                            "positionBinB",
300                                        ),
301                                    );
302                                }
303                                m_positionBinB = _serde::__private::Some(
304                                    match __A::next_value::<Vector4>(&mut __map) {
305                                        _serde::__private::Ok(__val) => __val,
306                                        _serde::__private::Err(__err) => {
307                                            return _serde::__private::Err(__err);
308                                        }
309                                    },
310                                );
311                            }
312                            3usize => {
313                                if _serde::__private::Option::is_some(&m_restLength) {
314                                    return _serde::__private::Err(
315                                        <__A::Error as _serde::de::Error>::duplicate_field(
316                                            "restLength",
317                                        ),
318                                    );
319                                }
320                                m_restLength = _serde::__private::Some(
321                                    match __A::next_value::<f32>(&mut __map) {
322                                        _serde::__private::Ok(__val) => __val,
323                                        _serde::__private::Err(__err) => {
324                                            return _serde::__private::Err(__err);
325                                        }
326                                    },
327                                );
328                            }
329                            4usize => {
330                                if _serde::__private::Option::is_some(&m_strength) {
331                                    return _serde::__private::Err(
332                                        <__A::Error as _serde::de::Error>::duplicate_field(
333                                            "strength",
334                                        ),
335                                    );
336                                }
337                                m_strength = _serde::__private::Some(
338                                    match __A::next_value::<f32>(&mut __map) {
339                                        _serde::__private::Ok(__val) => __val,
340                                        _serde::__private::Err(__err) => {
341                                            return _serde::__private::Err(__err);
342                                        }
343                                    },
344                                );
345                            }
346                            5usize => {
347                                if _serde::__private::Option::is_some(&m_damping) {
348                                    return _serde::__private::Err(
349                                        <__A::Error as _serde::de::Error>::duplicate_field(
350                                            "damping",
351                                        ),
352                                    );
353                                }
354                                m_damping = _serde::__private::Some(
355                                    match __A::next_value::<f32>(&mut __map) {
356                                        _serde::__private::Ok(__val) => __val,
357                                        _serde::__private::Err(__err) => {
358                                            return _serde::__private::Err(__err);
359                                        }
360                                    },
361                                );
362                            }
363                            6usize => {
364                                if _serde::__private::Option::is_some(&m_onCompression) {
365                                    return _serde::__private::Err(
366                                        <__A::Error as _serde::de::Error>::duplicate_field(
367                                            "onCompression",
368                                        ),
369                                    );
370                                }
371                                m_onCompression = _serde::__private::Some(
372                                    match __A::next_value::<bool>(&mut __map) {
373                                        _serde::__private::Ok(__val) => __val,
374                                        _serde::__private::Err(__err) => {
375                                            return _serde::__private::Err(__err);
376                                        }
377                                    },
378                                );
379                            }
380                            7usize => {
381                                if _serde::__private::Option::is_some(&m_onExtension) {
382                                    return _serde::__private::Err(
383                                        <__A::Error as _serde::de::Error>::duplicate_field(
384                                            "onExtension",
385                                        ),
386                                    );
387                                }
388                                m_onExtension = _serde::__private::Some(
389                                    match __A::next_value::<bool>(&mut __map) {
390                                        _serde::__private::Ok(__val) => __val,
391                                        _serde::__private::Err(__err) => {
392                                            return _serde::__private::Err(__err);
393                                        }
394                                    },
395                                );
396                            }
397                            _ => {}
398                        }
399                    }
400                    __A::pad(&mut __map, 2usize, 2usize)?;
401                    let m_lastForce = match m_lastForce {
402                        _serde::__private::Some(__field) => __field,
403                        _serde::__private::None => {
404                            return _serde::__private::Err(
405                                <__A::Error as _serde::de::Error>::missing_field(
406                                    "lastForce",
407                                ),
408                            );
409                        }
410                    };
411                    let m_positionAinA = match m_positionAinA {
412                        _serde::__private::Some(__field) => __field,
413                        _serde::__private::None => {
414                            return _serde::__private::Err(
415                                <__A::Error as _serde::de::Error>::missing_field(
416                                    "positionAinA",
417                                ),
418                            );
419                        }
420                    };
421                    let m_positionBinB = match m_positionBinB {
422                        _serde::__private::Some(__field) => __field,
423                        _serde::__private::None => {
424                            return _serde::__private::Err(
425                                <__A::Error as _serde::de::Error>::missing_field(
426                                    "positionBinB",
427                                ),
428                            );
429                        }
430                    };
431                    let m_restLength = match m_restLength {
432                        _serde::__private::Some(__field) => __field,
433                        _serde::__private::None => {
434                            return _serde::__private::Err(
435                                <__A::Error as _serde::de::Error>::missing_field(
436                                    "restLength",
437                                ),
438                            );
439                        }
440                    };
441                    let m_strength = match m_strength {
442                        _serde::__private::Some(__field) => __field,
443                        _serde::__private::None => {
444                            return _serde::__private::Err(
445                                <__A::Error as _serde::de::Error>::missing_field("strength"),
446                            );
447                        }
448                    };
449                    let m_damping = match m_damping {
450                        _serde::__private::Some(__field) => __field,
451                        _serde::__private::None => {
452                            return _serde::__private::Err(
453                                <__A::Error as _serde::de::Error>::missing_field("damping"),
454                            );
455                        }
456                    };
457                    let m_onCompression = match m_onCompression {
458                        _serde::__private::Some(__field) => __field,
459                        _serde::__private::None => {
460                            return _serde::__private::Err(
461                                <__A::Error as _serde::de::Error>::missing_field(
462                                    "onCompression",
463                                ),
464                            );
465                        }
466                    };
467                    let m_onExtension = match m_onExtension {
468                        _serde::__private::Some(__field) => __field,
469                        _serde::__private::None => {
470                            return _serde::__private::Err(
471                                <__A::Error as _serde::de::Error>::missing_field(
472                                    "onExtension",
473                                ),
474                            );
475                        }
476                    };
477                    _serde::__private::Ok(hkpSpringAction {
478                        __ptr,
479                        parent,
480                        m_lastForce,
481                        m_positionAinA,
482                        m_positionBinB,
483                        m_restLength,
484                        m_strength,
485                        m_damping,
486                        m_onCompression,
487                        m_onExtension,
488                    })
489                }
490                #[allow(clippy::manual_unwrap_or_default)]
491                fn visit_struct<__A>(
492                    self,
493                    mut __map: __A,
494                ) -> _serde::__private::Result<Self::Value, __A::Error>
495                where
496                    __A: _serde::de::MapAccess<'de>,
497                {
498                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
499                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
500                    let mut m_entityA: _serde::__private::Option<Pointer> = _serde::__private::None;
501                    let mut m_entityB: _serde::__private::Option<Pointer> = _serde::__private::None;
502                    let mut m_lastForce: _serde::__private::Option<Vector4> = _serde::__private::None;
503                    let mut m_positionAinA: _serde::__private::Option<Vector4> = _serde::__private::None;
504                    let mut m_positionBinB: _serde::__private::Option<Vector4> = _serde::__private::None;
505                    let mut m_restLength: _serde::__private::Option<f32> = _serde::__private::None;
506                    let mut m_strength: _serde::__private::Option<f32> = _serde::__private::None;
507                    let mut m_damping: _serde::__private::Option<f32> = _serde::__private::None;
508                    let mut m_onCompression: _serde::__private::Option<bool> = _serde::__private::None;
509                    let mut m_onExtension: _serde::__private::Option<bool> = _serde::__private::None;
510                    while let _serde::__private::Some(__key) = {
511                        __A::next_key::<__Field>(&mut __map)?
512                    } {
513                        match __key {
514                            __Field::m_userData => {
515                                #[cfg(
516                                    any(feature = "strict", feature = "ignore_duplicates")
517                                )]
518                                if _serde::__private::Option::is_some(&m_userData) {
519                                    #[cfg(feature = "ignore_duplicates")]
520                                    {
521                                        __A::skip_value(&mut __map)?;
522                                        continue;
523                                    }
524                                    #[cfg(feature = "strict")]
525                                    return _serde::__private::Err(
526                                        <__A::Error as _serde::de::Error>::duplicate_field(
527                                            "userData",
528                                        ),
529                                    );
530                                }
531                                m_userData = _serde::__private::Some(
532                                    match __A::next_value::<Ulong>(&mut __map) {
533                                        _serde::__private::Ok(__val) => __val,
534                                        _serde::__private::Err(__err) => {
535                                            return _serde::__private::Err(__err);
536                                        }
537                                    },
538                                );
539                            }
540                            __Field::m_name => {
541                                #[cfg(
542                                    any(feature = "strict", feature = "ignore_duplicates")
543                                )]
544                                if _serde::__private::Option::is_some(&m_name) {
545                                    #[cfg(feature = "ignore_duplicates")]
546                                    {
547                                        __A::skip_value(&mut __map)?;
548                                        continue;
549                                    }
550                                    #[cfg(feature = "strict")]
551                                    return _serde::__private::Err(
552                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
553                                    );
554                                }
555                                m_name = _serde::__private::Some(
556                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
557                                        _serde::__private::Ok(__val) => __val,
558                                        _serde::__private::Err(__err) => {
559                                            return _serde::__private::Err(__err);
560                                        }
561                                    },
562                                );
563                            }
564                            __Field::m_entityA => {
565                                #[cfg(
566                                    any(feature = "strict", feature = "ignore_duplicates")
567                                )]
568                                if _serde::__private::Option::is_some(&m_entityA) {
569                                    #[cfg(feature = "ignore_duplicates")]
570                                    {
571                                        __A::skip_value(&mut __map)?;
572                                        continue;
573                                    }
574                                    #[cfg(feature = "strict")]
575                                    return _serde::__private::Err(
576                                        <__A::Error as _serde::de::Error>::duplicate_field(
577                                            "entityA",
578                                        ),
579                                    );
580                                }
581                                m_entityA = _serde::__private::Some(
582                                    match __A::next_value::<Pointer>(&mut __map) {
583                                        _serde::__private::Ok(__val) => __val,
584                                        _serde::__private::Err(__err) => {
585                                            return _serde::__private::Err(__err);
586                                        }
587                                    },
588                                );
589                            }
590                            __Field::m_entityB => {
591                                #[cfg(
592                                    any(feature = "strict", feature = "ignore_duplicates")
593                                )]
594                                if _serde::__private::Option::is_some(&m_entityB) {
595                                    #[cfg(feature = "ignore_duplicates")]
596                                    {
597                                        __A::skip_value(&mut __map)?;
598                                        continue;
599                                    }
600                                    #[cfg(feature = "strict")]
601                                    return _serde::__private::Err(
602                                        <__A::Error as _serde::de::Error>::duplicate_field(
603                                            "entityB",
604                                        ),
605                                    );
606                                }
607                                m_entityB = _serde::__private::Some(
608                                    match __A::next_value::<Pointer>(&mut __map) {
609                                        _serde::__private::Ok(__val) => __val,
610                                        _serde::__private::Err(__err) => {
611                                            return _serde::__private::Err(__err);
612                                        }
613                                    },
614                                );
615                            }
616                            __Field::m_lastForce => {
617                                #[cfg(
618                                    any(feature = "strict", feature = "ignore_duplicates")
619                                )]
620                                if _serde::__private::Option::is_some(&m_lastForce) {
621                                    #[cfg(feature = "ignore_duplicates")]
622                                    {
623                                        __A::skip_value(&mut __map)?;
624                                        continue;
625                                    }
626                                    #[cfg(feature = "strict")]
627                                    return _serde::__private::Err(
628                                        <__A::Error as _serde::de::Error>::duplicate_field(
629                                            "lastForce",
630                                        ),
631                                    );
632                                }
633                                m_lastForce = _serde::__private::Some(
634                                    match __A::next_value::<Vector4>(&mut __map) {
635                                        _serde::__private::Ok(__val) => __val,
636                                        _serde::__private::Err(__err) => {
637                                            return _serde::__private::Err(__err);
638                                        }
639                                    },
640                                );
641                            }
642                            __Field::m_positionAinA => {
643                                #[cfg(
644                                    any(feature = "strict", feature = "ignore_duplicates")
645                                )]
646                                if _serde::__private::Option::is_some(&m_positionAinA) {
647                                    #[cfg(feature = "ignore_duplicates")]
648                                    {
649                                        __A::skip_value(&mut __map)?;
650                                        continue;
651                                    }
652                                    #[cfg(feature = "strict")]
653                                    return _serde::__private::Err(
654                                        <__A::Error as _serde::de::Error>::duplicate_field(
655                                            "positionAinA",
656                                        ),
657                                    );
658                                }
659                                m_positionAinA = _serde::__private::Some(
660                                    match __A::next_value::<Vector4>(&mut __map) {
661                                        _serde::__private::Ok(__val) => __val,
662                                        _serde::__private::Err(__err) => {
663                                            return _serde::__private::Err(__err);
664                                        }
665                                    },
666                                );
667                            }
668                            __Field::m_positionBinB => {
669                                #[cfg(
670                                    any(feature = "strict", feature = "ignore_duplicates")
671                                )]
672                                if _serde::__private::Option::is_some(&m_positionBinB) {
673                                    #[cfg(feature = "ignore_duplicates")]
674                                    {
675                                        __A::skip_value(&mut __map)?;
676                                        continue;
677                                    }
678                                    #[cfg(feature = "strict")]
679                                    return _serde::__private::Err(
680                                        <__A::Error as _serde::de::Error>::duplicate_field(
681                                            "positionBinB",
682                                        ),
683                                    );
684                                }
685                                m_positionBinB = _serde::__private::Some(
686                                    match __A::next_value::<Vector4>(&mut __map) {
687                                        _serde::__private::Ok(__val) => __val,
688                                        _serde::__private::Err(__err) => {
689                                            return _serde::__private::Err(__err);
690                                        }
691                                    },
692                                );
693                            }
694                            __Field::m_restLength => {
695                                #[cfg(
696                                    any(feature = "strict", feature = "ignore_duplicates")
697                                )]
698                                if _serde::__private::Option::is_some(&m_restLength) {
699                                    #[cfg(feature = "ignore_duplicates")]
700                                    {
701                                        __A::skip_value(&mut __map)?;
702                                        continue;
703                                    }
704                                    #[cfg(feature = "strict")]
705                                    return _serde::__private::Err(
706                                        <__A::Error as _serde::de::Error>::duplicate_field(
707                                            "restLength",
708                                        ),
709                                    );
710                                }
711                                m_restLength = _serde::__private::Some(
712                                    match __A::next_value::<f32>(&mut __map) {
713                                        _serde::__private::Ok(__val) => __val,
714                                        _serde::__private::Err(__err) => {
715                                            return _serde::__private::Err(__err);
716                                        }
717                                    },
718                                );
719                            }
720                            __Field::m_strength => {
721                                #[cfg(
722                                    any(feature = "strict", feature = "ignore_duplicates")
723                                )]
724                                if _serde::__private::Option::is_some(&m_strength) {
725                                    #[cfg(feature = "ignore_duplicates")]
726                                    {
727                                        __A::skip_value(&mut __map)?;
728                                        continue;
729                                    }
730                                    #[cfg(feature = "strict")]
731                                    return _serde::__private::Err(
732                                        <__A::Error as _serde::de::Error>::duplicate_field(
733                                            "strength",
734                                        ),
735                                    );
736                                }
737                                m_strength = _serde::__private::Some(
738                                    match __A::next_value::<f32>(&mut __map) {
739                                        _serde::__private::Ok(__val) => __val,
740                                        _serde::__private::Err(__err) => {
741                                            return _serde::__private::Err(__err);
742                                        }
743                                    },
744                                );
745                            }
746                            __Field::m_damping => {
747                                #[cfg(
748                                    any(feature = "strict", feature = "ignore_duplicates")
749                                )]
750                                if _serde::__private::Option::is_some(&m_damping) {
751                                    #[cfg(feature = "ignore_duplicates")]
752                                    {
753                                        __A::skip_value(&mut __map)?;
754                                        continue;
755                                    }
756                                    #[cfg(feature = "strict")]
757                                    return _serde::__private::Err(
758                                        <__A::Error as _serde::de::Error>::duplicate_field(
759                                            "damping",
760                                        ),
761                                    );
762                                }
763                                m_damping = _serde::__private::Some(
764                                    match __A::next_value::<f32>(&mut __map) {
765                                        _serde::__private::Ok(__val) => __val,
766                                        _serde::__private::Err(__err) => {
767                                            return _serde::__private::Err(__err);
768                                        }
769                                    },
770                                );
771                            }
772                            __Field::m_onCompression => {
773                                #[cfg(
774                                    any(feature = "strict", feature = "ignore_duplicates")
775                                )]
776                                if _serde::__private::Option::is_some(&m_onCompression) {
777                                    #[cfg(feature = "ignore_duplicates")]
778                                    {
779                                        __A::skip_value(&mut __map)?;
780                                        continue;
781                                    }
782                                    #[cfg(feature = "strict")]
783                                    return _serde::__private::Err(
784                                        <__A::Error as _serde::de::Error>::duplicate_field(
785                                            "onCompression",
786                                        ),
787                                    );
788                                }
789                                m_onCompression = _serde::__private::Some(
790                                    match __A::next_value::<bool>(&mut __map) {
791                                        _serde::__private::Ok(__val) => __val,
792                                        _serde::__private::Err(__err) => {
793                                            return _serde::__private::Err(__err);
794                                        }
795                                    },
796                                );
797                            }
798                            __Field::m_onExtension => {
799                                #[cfg(
800                                    any(feature = "strict", feature = "ignore_duplicates")
801                                )]
802                                if _serde::__private::Option::is_some(&m_onExtension) {
803                                    #[cfg(feature = "ignore_duplicates")]
804                                    {
805                                        __A::skip_value(&mut __map)?;
806                                        continue;
807                                    }
808                                    #[cfg(feature = "strict")]
809                                    return _serde::__private::Err(
810                                        <__A::Error as _serde::de::Error>::duplicate_field(
811                                            "onExtension",
812                                        ),
813                                    );
814                                }
815                                m_onExtension = _serde::__private::Some(
816                                    match __A::next_value::<bool>(&mut __map) {
817                                        _serde::__private::Ok(__val) => __val,
818                                        _serde::__private::Err(__err) => {
819                                            return _serde::__private::Err(__err);
820                                        }
821                                    },
822                                );
823                            }
824                            _ => __A::skip_value(&mut __map)?,
825                        }
826                    }
827                    let m_userData = match m_userData {
828                        _serde::__private::Some(__field) => __field,
829                        _serde::__private::None => {
830                            #[cfg(feature = "strict")]
831                            return _serde::__private::Err(
832                                <__A::Error as _serde::de::Error>::missing_field("userData"),
833                            );
834                            #[cfg(not(feature = "strict"))] Default::default()
835                        }
836                    };
837                    let m_name = match m_name {
838                        _serde::__private::Some(__field) => __field,
839                        _serde::__private::None => {
840                            #[cfg(feature = "strict")]
841                            return _serde::__private::Err(
842                                <__A::Error as _serde::de::Error>::missing_field("name"),
843                            );
844                            #[cfg(not(feature = "strict"))] Default::default()
845                        }
846                    };
847                    let m_entityA = match m_entityA {
848                        _serde::__private::Some(__field) => __field,
849                        _serde::__private::None => {
850                            #[cfg(feature = "strict")]
851                            return _serde::__private::Err(
852                                <__A::Error as _serde::de::Error>::missing_field("entityA"),
853                            );
854                            #[cfg(not(feature = "strict"))] Default::default()
855                        }
856                    };
857                    let m_entityB = match m_entityB {
858                        _serde::__private::Some(__field) => __field,
859                        _serde::__private::None => {
860                            #[cfg(feature = "strict")]
861                            return _serde::__private::Err(
862                                <__A::Error as _serde::de::Error>::missing_field("entityB"),
863                            );
864                            #[cfg(not(feature = "strict"))] Default::default()
865                        }
866                    };
867                    let m_lastForce = match m_lastForce {
868                        _serde::__private::Some(__field) => __field,
869                        _serde::__private::None => {
870                            #[cfg(feature = "strict")]
871                            return _serde::__private::Err(
872                                <__A::Error as _serde::de::Error>::missing_field(
873                                    "lastForce",
874                                ),
875                            );
876                            #[cfg(not(feature = "strict"))] Default::default()
877                        }
878                    };
879                    let m_positionAinA = match m_positionAinA {
880                        _serde::__private::Some(__field) => __field,
881                        _serde::__private::None => {
882                            #[cfg(feature = "strict")]
883                            return _serde::__private::Err(
884                                <__A::Error as _serde::de::Error>::missing_field(
885                                    "positionAinA",
886                                ),
887                            );
888                            #[cfg(not(feature = "strict"))] Default::default()
889                        }
890                    };
891                    let m_positionBinB = match m_positionBinB {
892                        _serde::__private::Some(__field) => __field,
893                        _serde::__private::None => {
894                            #[cfg(feature = "strict")]
895                            return _serde::__private::Err(
896                                <__A::Error as _serde::de::Error>::missing_field(
897                                    "positionBinB",
898                                ),
899                            );
900                            #[cfg(not(feature = "strict"))] Default::default()
901                        }
902                    };
903                    let m_restLength = match m_restLength {
904                        _serde::__private::Some(__field) => __field,
905                        _serde::__private::None => {
906                            #[cfg(feature = "strict")]
907                            return _serde::__private::Err(
908                                <__A::Error as _serde::de::Error>::missing_field(
909                                    "restLength",
910                                ),
911                            );
912                            #[cfg(not(feature = "strict"))] Default::default()
913                        }
914                    };
915                    let m_strength = match m_strength {
916                        _serde::__private::Some(__field) => __field,
917                        _serde::__private::None => {
918                            #[cfg(feature = "strict")]
919                            return _serde::__private::Err(
920                                <__A::Error as _serde::de::Error>::missing_field("strength"),
921                            );
922                            #[cfg(not(feature = "strict"))] Default::default()
923                        }
924                    };
925                    let m_damping = match m_damping {
926                        _serde::__private::Some(__field) => __field,
927                        _serde::__private::None => {
928                            #[cfg(feature = "strict")]
929                            return _serde::__private::Err(
930                                <__A::Error as _serde::de::Error>::missing_field("damping"),
931                            );
932                            #[cfg(not(feature = "strict"))] Default::default()
933                        }
934                    };
935                    let m_onCompression = match m_onCompression {
936                        _serde::__private::Some(__field) => __field,
937                        _serde::__private::None => {
938                            #[cfg(feature = "strict")]
939                            return _serde::__private::Err(
940                                <__A::Error as _serde::de::Error>::missing_field(
941                                    "onCompression",
942                                ),
943                            );
944                            #[cfg(not(feature = "strict"))] Default::default()
945                        }
946                    };
947                    let m_onExtension = match m_onExtension {
948                        _serde::__private::Some(__field) => __field,
949                        _serde::__private::None => {
950                            #[cfg(feature = "strict")]
951                            return _serde::__private::Err(
952                                <__A::Error as _serde::de::Error>::missing_field(
953                                    "onExtension",
954                                ),
955                            );
956                            #[cfg(not(feature = "strict"))] Default::default()
957                        }
958                    };
959                    let __ptr = None;
960                    let parent = hkBaseObject { __ptr };
961                    let parent = hkReferencedObject {
962                        __ptr,
963                        parent,
964                        ..Default::default()
965                    };
966                    let parent = hkpAction {
967                        __ptr,
968                        parent,
969                        m_userData,
970                        m_name,
971                        ..Default::default()
972                    };
973                    let parent = hkpBinaryAction {
974                        __ptr,
975                        parent,
976                        m_entityA,
977                        m_entityB,
978                    };
979                    let __ptr = __A::class_ptr(&mut __map);
980                    _serde::__private::Ok(hkpSpringAction {
981                        __ptr,
982                        parent,
983                        m_lastForce,
984                        m_positionAinA,
985                        m_positionBinB,
986                        m_restLength,
987                        m_strength,
988                        m_damping,
989                        m_onCompression,
990                        m_onExtension,
991                    })
992                }
993            }
994            const FIELDS: &[&str] = &[
995                "lastForce",
996                "positionAinA",
997                "positionBinB",
998                "restLength",
999                "strength",
1000                "damping",
1001                "onCompression",
1002                "onExtension",
1003            ];
1004            _serde::Deserializer::deserialize_struct(
1005                deserializer,
1006                "hkpSpringAction",
1007                FIELDS,
1008                __hkpSpringActionVisitor {
1009                    marker: _serde::__private::PhantomData::<hkpSpringAction>,
1010                    lifetime: _serde::__private::PhantomData,
1011                },
1012            )
1013        }
1014    }
1015};