havok_classes/generated/
hkpSimpleContactConstraintDataInfo_.rs

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

havok_classes/generated/
hkpSimpleContactConstraintDataInfo_.rs
