havok_classes/generated/
hkpPoweredChainDataConstraintInfo_.rs

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

havok_classes/generated/
hkpPoweredChainDataConstraintInfo_.rs
