havok_classes/generated/
hkpPrismaticConstraintDataAtoms_.rs

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

havok_classes/generated/
hkpPrismaticConstraintDataAtoms_.rs
