havok_classes/generated/
hkpBallSocketChainData_.rs

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

havok_classes/generated/
hkpBallSocketChainData_.rs
