havok_classes/generated/
hkpRagdollMotorConstraintAtom_.rs

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

havok_classes/generated/
hkpRagdollMotorConstraintAtom_.rs
