havok_classes/generated/
hkpCallbackConstraintMotor_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpCallbackConstraintMotor`
5/// - version: `0`
6/// - signature: `0xafcd79ad`
7/// - size: ` 40`(x86)/` 72`(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 hkpCallbackConstraintMotor {
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: hkpLimitedForceConstraintMotor,
30    /// # C++ Info
31    /// - name: `callbackFunc`(ctype: `void*`)
32    /// - offset: ` 20`(x86)/` 32`(x86_64)
33    /// - type_size: `  4`(x86)/`  8`(x86_64)
34    /// - flags: `SERIALIZE_IGNORED`
35    #[cfg_attr(feature = "json_schema", schemars(rename = "callbackFunc"))]
36    #[cfg_attr(feature = "serde", serde(rename = "callbackFunc"))]
37    pub m_callbackFunc: Pointer,
38    /// # C++ Info
39    /// - name: `callbackType`(ctype: `enum CallbackType`)
40    /// - offset: ` 24`(x86)/` 40`(x86_64)
41    /// - type_size: `  4`(x86)/`  4`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "callbackType"))]
43    #[cfg_attr(feature = "serde", serde(rename = "callbackType"))]
44    pub m_callbackType: CallbackType,
45    /// # C++ Info
46    /// - name: `userData0`(ctype: `hkUlong`)
47    /// - offset: ` 28`(x86)/` 48`(x86_64)
48    /// - type_size: `  4`(x86)/`  8`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "userData0"))]
50    #[cfg_attr(feature = "serde", serde(rename = "userData0"))]
51    pub m_userData0: Ulong,
52    /// # C++ Info
53    /// - name: `userData1`(ctype: `hkUlong`)
54    /// - offset: ` 32`(x86)/` 56`(x86_64)
55    /// - type_size: `  4`(x86)/`  8`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "userData1"))]
57    #[cfg_attr(feature = "serde", serde(rename = "userData1"))]
58    pub m_userData1: Ulong,
59    /// # C++ Info
60    /// - name: `userData2`(ctype: `hkUlong`)
61    /// - offset: ` 36`(x86)/` 64`(x86_64)
62    /// - type_size: `  4`(x86)/`  8`(x86_64)
63    #[cfg_attr(feature = "json_schema", schemars(rename = "userData2"))]
64    #[cfg_attr(feature = "serde", serde(rename = "userData2"))]
65    pub m_userData2: Ulong,
66}
67const _: () = {
68    use havok_serde as _serde;
69    impl _serde::HavokClass for hkpCallbackConstraintMotor {
70        #[inline]
71        fn name(&self) -> &'static str {
72            "hkpCallbackConstraintMotor"
73        }
74        #[inline]
75        fn signature(&self) -> _serde::__private::Signature {
76            _serde::__private::Signature::new(0xafcd79ad)
77        }
78        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
79        fn deps_indexes(&self) -> Vec<usize> {
80            let mut v = Vec::new();
81            v.push(self.m_callbackFunc.get());
82            v
83        }
84    }
85    impl _serde::Serialize for hkpCallbackConstraintMotor {
86        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
87        where
88            S: _serde::ser::Serializer,
89        {
90            let class_meta = self
91                .__ptr
92                .map(|name| (name, _serde::__private::Signature::new(0xafcd79ad)));
93            let mut serializer = __serializer
94                .serialize_struct(
95                    "hkpCallbackConstraintMotor",
96                    class_meta,
97                    (40u64, 72u64),
98                )?;
99            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
100            serializer
101                .skip_field(
102                    "memSizeAndFlags",
103                    &self.parent.parent.parent.m_memSizeAndFlags,
104                )?;
105            serializer
106                .skip_field(
107                    "referenceCount",
108                    &self.parent.parent.parent.m_referenceCount,
109                )?;
110            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
111            serializer.serialize_field("type", &self.parent.parent.m_type)?;
112            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
113            serializer.serialize_field("minForce", &self.parent.m_minForce)?;
114            serializer.serialize_field("maxForce", &self.parent.m_maxForce)?;
115            serializer.skip_field("callbackFunc", &self.m_callbackFunc)?;
116            serializer.serialize_field("callbackType", &self.m_callbackType)?;
117            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118            serializer.serialize_field("userData0", &self.m_userData0)?;
119            serializer.serialize_field("userData1", &self.m_userData1)?;
120            serializer.serialize_field("userData2", &self.m_userData2)?;
121            serializer.end()
122        }
123    }
124};
125#[doc(hidden)]
126#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
127const _: () = {
128    use havok_serde as _serde;
129    #[automatically_derived]
130    impl<'de> _serde::Deserialize<'de> for hkpCallbackConstraintMotor {
131        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
132        where
133            __D: _serde::Deserializer<'de>,
134        {
135            #[allow(non_camel_case_types)]
136            enum __Field {
137                m_type,
138                m_minForce,
139                m_maxForce,
140                m_callbackType,
141                m_userData0,
142                m_userData1,
143                m_userData2,
144                __ignore,
145            }
146            struct __FieldVisitor;
147            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
148                type Value = __Field;
149                fn expecting(
150                    &self,
151                    __formatter: &mut core::fmt::Formatter,
152                ) -> core::fmt::Result {
153                    core::fmt::Formatter::write_str(__formatter, "field identifier")
154                }
155                /// Intended for use in XML.
156                #[allow(clippy::match_single_binding)]
157                #[allow(clippy::reversed_empty_ranges)]
158                #[allow(clippy::single_match)]
159                fn visit_key<__E>(
160                    self,
161                    __value: &str,
162                ) -> core::result::Result<Self::Value, __E>
163                where
164                    __E: _serde::de::Error,
165                {
166                    match __value {
167                        "type" => Ok(__Field::m_type),
168                        "minForce" => Ok(__Field::m_minForce),
169                        "maxForce" => Ok(__Field::m_maxForce),
170                        "callbackType" => Ok(__Field::m_callbackType),
171                        "userData0" => Ok(__Field::m_userData0),
172                        "userData1" => Ok(__Field::m_userData1),
173                        "userData2" => Ok(__Field::m_userData2),
174                        _ => Ok(__Field::__ignore),
175                    }
176                }
177            }
178            impl<'de> _serde::Deserialize<'de> for __Field {
179                #[inline]
180                fn deserialize<__D>(
181                    __deserializer: __D,
182                ) -> core::result::Result<Self, __D::Error>
183                where
184                    __D: _serde::Deserializer<'de>,
185                {
186                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
187                }
188            }
189            struct __hkpCallbackConstraintMotorVisitor<'de> {
190                marker: _serde::__private::PhantomData<hkpCallbackConstraintMotor>,
191                lifetime: _serde::__private::PhantomData<&'de ()>,
192            }
193            #[allow(clippy::match_single_binding)]
194            #[allow(clippy::reversed_empty_ranges)]
195            #[allow(clippy::single_match)]
196            impl<'de> _serde::de::Visitor<'de>
197            for __hkpCallbackConstraintMotorVisitor<'de> {
198                type Value = hkpCallbackConstraintMotor;
199                fn expecting(
200                    &self,
201                    __formatter: &mut core::fmt::Formatter,
202                ) -> core::fmt::Result {
203                    core::fmt::Formatter::write_str(
204                        __formatter,
205                        "struct hkpCallbackConstraintMotor",
206                    )
207                }
208                fn visit_struct_for_bytes<__A>(
209                    self,
210                    mut __map: __A,
211                ) -> _serde::__private::Result<Self::Value, __A::Error>
212                where
213                    __A: _serde::de::MapAccess<'de>,
214                {
215                    let __ptr = __A::class_ptr(&mut __map);
216                    let parent = __A::parent_value(&mut __map)?;
217                    let mut m_callbackFunc: _serde::__private::Option<Pointer> = _serde::__private::None;
218                    let mut m_callbackType: _serde::__private::Option<CallbackType> = _serde::__private::None;
219                    let mut m_userData0: _serde::__private::Option<Ulong> = _serde::__private::None;
220                    let mut m_userData1: _serde::__private::Option<Ulong> = _serde::__private::None;
221                    let mut m_userData2: _serde::__private::Option<Ulong> = _serde::__private::None;
222                    for i in 0..5usize {
223                        match i {
224                            0usize => {
225                                if _serde::__private::Option::is_some(&m_callbackFunc) {
226                                    return _serde::__private::Err(
227                                        <__A::Error as _serde::de::Error>::duplicate_field(
228                                            "callbackFunc",
229                                        ),
230                                    );
231                                }
232                                m_callbackFunc = _serde::__private::Some(
233                                    match __A::next_value::<Pointer>(&mut __map) {
234                                        _serde::__private::Ok(__val) => __val,
235                                        _serde::__private::Err(__err) => {
236                                            return _serde::__private::Err(__err);
237                                        }
238                                    },
239                                );
240                            }
241                            1usize => {
242                                if _serde::__private::Option::is_some(&m_callbackType) {
243                                    return _serde::__private::Err(
244                                        <__A::Error as _serde::de::Error>::duplicate_field(
245                                            "callbackType",
246                                        ),
247                                    );
248                                }
249                                m_callbackType = _serde::__private::Some(
250                                    match __A::next_value::<CallbackType>(&mut __map) {
251                                        _serde::__private::Ok(__val) => __val,
252                                        _serde::__private::Err(__err) => {
253                                            return _serde::__private::Err(__err);
254                                        }
255                                    },
256                                );
257                            }
258                            2usize => {
259                                if _serde::__private::Option::is_some(&m_userData0) {
260                                    return _serde::__private::Err(
261                                        <__A::Error as _serde::de::Error>::duplicate_field(
262                                            "userData0",
263                                        ),
264                                    );
265                                }
266                                __A::pad(&mut __map, 0usize, 4usize)?;
267                                m_userData0 = _serde::__private::Some(
268                                    match __A::next_value::<Ulong>(&mut __map) {
269                                        _serde::__private::Ok(__val) => __val,
270                                        _serde::__private::Err(__err) => {
271                                            return _serde::__private::Err(__err);
272                                        }
273                                    },
274                                );
275                            }
276                            3usize => {
277                                if _serde::__private::Option::is_some(&m_userData1) {
278                                    return _serde::__private::Err(
279                                        <__A::Error as _serde::de::Error>::duplicate_field(
280                                            "userData1",
281                                        ),
282                                    );
283                                }
284                                m_userData1 = _serde::__private::Some(
285                                    match __A::next_value::<Ulong>(&mut __map) {
286                                        _serde::__private::Ok(__val) => __val,
287                                        _serde::__private::Err(__err) => {
288                                            return _serde::__private::Err(__err);
289                                        }
290                                    },
291                                );
292                            }
293                            4usize => {
294                                if _serde::__private::Option::is_some(&m_userData2) {
295                                    return _serde::__private::Err(
296                                        <__A::Error as _serde::de::Error>::duplicate_field(
297                                            "userData2",
298                                        ),
299                                    );
300                                }
301                                m_userData2 = _serde::__private::Some(
302                                    match __A::next_value::<Ulong>(&mut __map) {
303                                        _serde::__private::Ok(__val) => __val,
304                                        _serde::__private::Err(__err) => {
305                                            return _serde::__private::Err(__err);
306                                        }
307                                    },
308                                );
309                            }
310                            _ => {}
311                        }
312                    }
313                    let m_callbackFunc = match m_callbackFunc {
314                        _serde::__private::Some(__field) => __field,
315                        _serde::__private::None => {
316                            return _serde::__private::Err(
317                                <__A::Error as _serde::de::Error>::missing_field(
318                                    "callbackFunc",
319                                ),
320                            );
321                        }
322                    };
323                    let m_callbackType = match m_callbackType {
324                        _serde::__private::Some(__field) => __field,
325                        _serde::__private::None => {
326                            return _serde::__private::Err(
327                                <__A::Error as _serde::de::Error>::missing_field(
328                                    "callbackType",
329                                ),
330                            );
331                        }
332                    };
333                    let m_userData0 = match m_userData0 {
334                        _serde::__private::Some(__field) => __field,
335                        _serde::__private::None => {
336                            return _serde::__private::Err(
337                                <__A::Error as _serde::de::Error>::missing_field(
338                                    "userData0",
339                                ),
340                            );
341                        }
342                    };
343                    let m_userData1 = match m_userData1 {
344                        _serde::__private::Some(__field) => __field,
345                        _serde::__private::None => {
346                            return _serde::__private::Err(
347                                <__A::Error as _serde::de::Error>::missing_field(
348                                    "userData1",
349                                ),
350                            );
351                        }
352                    };
353                    let m_userData2 = match m_userData2 {
354                        _serde::__private::Some(__field) => __field,
355                        _serde::__private::None => {
356                            return _serde::__private::Err(
357                                <__A::Error as _serde::de::Error>::missing_field(
358                                    "userData2",
359                                ),
360                            );
361                        }
362                    };
363                    _serde::__private::Ok(hkpCallbackConstraintMotor {
364                        __ptr,
365                        parent,
366                        m_callbackFunc,
367                        m_callbackType,
368                        m_userData0,
369                        m_userData1,
370                        m_userData2,
371                    })
372                }
373                #[allow(clippy::manual_unwrap_or_default)]
374                fn visit_struct<__A>(
375                    self,
376                    mut __map: __A,
377                ) -> _serde::__private::Result<Self::Value, __A::Error>
378                where
379                    __A: _serde::de::MapAccess<'de>,
380                {
381                    let mut m_type: _serde::__private::Option<MotorType> = _serde::__private::None;
382                    let mut m_minForce: _serde::__private::Option<f32> = _serde::__private::None;
383                    let mut m_maxForce: _serde::__private::Option<f32> = _serde::__private::None;
384                    let mut m_callbackType: _serde::__private::Option<CallbackType> = _serde::__private::None;
385                    let mut m_userData0: _serde::__private::Option<Ulong> = _serde::__private::None;
386                    let mut m_userData1: _serde::__private::Option<Ulong> = _serde::__private::None;
387                    let mut m_userData2: _serde::__private::Option<Ulong> = _serde::__private::None;
388                    while let _serde::__private::Some(__key) = {
389                        __A::next_key::<__Field>(&mut __map)?
390                    } {
391                        match __key {
392                            __Field::m_type => {
393                                #[cfg(
394                                    any(feature = "strict", feature = "ignore_duplicates")
395                                )]
396                                if _serde::__private::Option::is_some(&m_type) {
397                                    #[cfg(feature = "ignore_duplicates")]
398                                    {
399                                        __A::skip_value(&mut __map)?;
400                                        continue;
401                                    }
402                                    #[cfg(feature = "strict")]
403                                    return _serde::__private::Err(
404                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
405                                    );
406                                }
407                                m_type = _serde::__private::Some(
408                                    match __A::next_value::<MotorType>(&mut __map) {
409                                        _serde::__private::Ok(__val) => __val,
410                                        _serde::__private::Err(__err) => {
411                                            return _serde::__private::Err(__err);
412                                        }
413                                    },
414                                );
415                            }
416                            __Field::m_minForce => {
417                                #[cfg(
418                                    any(feature = "strict", feature = "ignore_duplicates")
419                                )]
420                                if _serde::__private::Option::is_some(&m_minForce) {
421                                    #[cfg(feature = "ignore_duplicates")]
422                                    {
423                                        __A::skip_value(&mut __map)?;
424                                        continue;
425                                    }
426                                    #[cfg(feature = "strict")]
427                                    return _serde::__private::Err(
428                                        <__A::Error as _serde::de::Error>::duplicate_field(
429                                            "minForce",
430                                        ),
431                                    );
432                                }
433                                m_minForce = _serde::__private::Some(
434                                    match __A::next_value::<f32>(&mut __map) {
435                                        _serde::__private::Ok(__val) => __val,
436                                        _serde::__private::Err(__err) => {
437                                            return _serde::__private::Err(__err);
438                                        }
439                                    },
440                                );
441                            }
442                            __Field::m_maxForce => {
443                                #[cfg(
444                                    any(feature = "strict", feature = "ignore_duplicates")
445                                )]
446                                if _serde::__private::Option::is_some(&m_maxForce) {
447                                    #[cfg(feature = "ignore_duplicates")]
448                                    {
449                                        __A::skip_value(&mut __map)?;
450                                        continue;
451                                    }
452                                    #[cfg(feature = "strict")]
453                                    return _serde::__private::Err(
454                                        <__A::Error as _serde::de::Error>::duplicate_field(
455                                            "maxForce",
456                                        ),
457                                    );
458                                }
459                                m_maxForce = _serde::__private::Some(
460                                    match __A::next_value::<f32>(&mut __map) {
461                                        _serde::__private::Ok(__val) => __val,
462                                        _serde::__private::Err(__err) => {
463                                            return _serde::__private::Err(__err);
464                                        }
465                                    },
466                                );
467                            }
468                            __Field::m_callbackType => {
469                                #[cfg(
470                                    any(feature = "strict", feature = "ignore_duplicates")
471                                )]
472                                if _serde::__private::Option::is_some(&m_callbackType) {
473                                    #[cfg(feature = "ignore_duplicates")]
474                                    {
475                                        __A::skip_value(&mut __map)?;
476                                        continue;
477                                    }
478                                    #[cfg(feature = "strict")]
479                                    return _serde::__private::Err(
480                                        <__A::Error as _serde::de::Error>::duplicate_field(
481                                            "callbackType",
482                                        ),
483                                    );
484                                }
485                                m_callbackType = _serde::__private::Some(
486                                    match __A::next_value::<CallbackType>(&mut __map) {
487                                        _serde::__private::Ok(__val) => __val,
488                                        _serde::__private::Err(__err) => {
489                                            return _serde::__private::Err(__err);
490                                        }
491                                    },
492                                );
493                            }
494                            __Field::m_userData0 => {
495                                #[cfg(
496                                    any(feature = "strict", feature = "ignore_duplicates")
497                                )]
498                                if _serde::__private::Option::is_some(&m_userData0) {
499                                    #[cfg(feature = "ignore_duplicates")]
500                                    {
501                                        __A::skip_value(&mut __map)?;
502                                        continue;
503                                    }
504                                    #[cfg(feature = "strict")]
505                                    return _serde::__private::Err(
506                                        <__A::Error as _serde::de::Error>::duplicate_field(
507                                            "userData0",
508                                        ),
509                                    );
510                                }
511                                m_userData0 = _serde::__private::Some(
512                                    match __A::next_value::<Ulong>(&mut __map) {
513                                        _serde::__private::Ok(__val) => __val,
514                                        _serde::__private::Err(__err) => {
515                                            return _serde::__private::Err(__err);
516                                        }
517                                    },
518                                );
519                            }
520                            __Field::m_userData1 => {
521                                #[cfg(
522                                    any(feature = "strict", feature = "ignore_duplicates")
523                                )]
524                                if _serde::__private::Option::is_some(&m_userData1) {
525                                    #[cfg(feature = "ignore_duplicates")]
526                                    {
527                                        __A::skip_value(&mut __map)?;
528                                        continue;
529                                    }
530                                    #[cfg(feature = "strict")]
531                                    return _serde::__private::Err(
532                                        <__A::Error as _serde::de::Error>::duplicate_field(
533                                            "userData1",
534                                        ),
535                                    );
536                                }
537                                m_userData1 = _serde::__private::Some(
538                                    match __A::next_value::<Ulong>(&mut __map) {
539                                        _serde::__private::Ok(__val) => __val,
540                                        _serde::__private::Err(__err) => {
541                                            return _serde::__private::Err(__err);
542                                        }
543                                    },
544                                );
545                            }
546                            __Field::m_userData2 => {
547                                #[cfg(
548                                    any(feature = "strict", feature = "ignore_duplicates")
549                                )]
550                                if _serde::__private::Option::is_some(&m_userData2) {
551                                    #[cfg(feature = "ignore_duplicates")]
552                                    {
553                                        __A::skip_value(&mut __map)?;
554                                        continue;
555                                    }
556                                    #[cfg(feature = "strict")]
557                                    return _serde::__private::Err(
558                                        <__A::Error as _serde::de::Error>::duplicate_field(
559                                            "userData2",
560                                        ),
561                                    );
562                                }
563                                m_userData2 = _serde::__private::Some(
564                                    match __A::next_value::<Ulong>(&mut __map) {
565                                        _serde::__private::Ok(__val) => __val,
566                                        _serde::__private::Err(__err) => {
567                                            return _serde::__private::Err(__err);
568                                        }
569                                    },
570                                );
571                            }
572                            _ => __A::skip_value(&mut __map)?,
573                        }
574                    }
575                    let m_type = match m_type {
576                        _serde::__private::Some(__field) => __field,
577                        _serde::__private::None => {
578                            #[cfg(feature = "strict")]
579                            return _serde::__private::Err(
580                                <__A::Error as _serde::de::Error>::missing_field("type"),
581                            );
582                            #[cfg(not(feature = "strict"))] Default::default()
583                        }
584                    };
585                    let m_minForce = match m_minForce {
586                        _serde::__private::Some(__field) => __field,
587                        _serde::__private::None => {
588                            #[cfg(feature = "strict")]
589                            return _serde::__private::Err(
590                                <__A::Error as _serde::de::Error>::missing_field("minForce"),
591                            );
592                            #[cfg(not(feature = "strict"))] Default::default()
593                        }
594                    };
595                    let m_maxForce = match m_maxForce {
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("maxForce"),
601                            );
602                            #[cfg(not(feature = "strict"))] Default::default()
603                        }
604                    };
605                    let m_callbackType = match m_callbackType {
606                        _serde::__private::Some(__field) => __field,
607                        _serde::__private::None => {
608                            #[cfg(feature = "strict")]
609                            return _serde::__private::Err(
610                                <__A::Error as _serde::de::Error>::missing_field(
611                                    "callbackType",
612                                ),
613                            );
614                            #[cfg(not(feature = "strict"))] Default::default()
615                        }
616                    };
617                    let m_userData0 = match m_userData0 {
618                        _serde::__private::Some(__field) => __field,
619                        _serde::__private::None => {
620                            #[cfg(feature = "strict")]
621                            return _serde::__private::Err(
622                                <__A::Error as _serde::de::Error>::missing_field(
623                                    "userData0",
624                                ),
625                            );
626                            #[cfg(not(feature = "strict"))] Default::default()
627                        }
628                    };
629                    let m_userData1 = match m_userData1 {
630                        _serde::__private::Some(__field) => __field,
631                        _serde::__private::None => {
632                            #[cfg(feature = "strict")]
633                            return _serde::__private::Err(
634                                <__A::Error as _serde::de::Error>::missing_field(
635                                    "userData1",
636                                ),
637                            );
638                            #[cfg(not(feature = "strict"))] Default::default()
639                        }
640                    };
641                    let m_userData2 = match m_userData2 {
642                        _serde::__private::Some(__field) => __field,
643                        _serde::__private::None => {
644                            #[cfg(feature = "strict")]
645                            return _serde::__private::Err(
646                                <__A::Error as _serde::de::Error>::missing_field(
647                                    "userData2",
648                                ),
649                            );
650                            #[cfg(not(feature = "strict"))] Default::default()
651                        }
652                    };
653                    let __ptr = None;
654                    let parent = hkBaseObject { __ptr };
655                    let parent = hkReferencedObject {
656                        __ptr,
657                        parent,
658                        ..Default::default()
659                    };
660                    let parent = hkpConstraintMotor {
661                        __ptr,
662                        parent,
663                        m_type,
664                    };
665                    let parent = hkpLimitedForceConstraintMotor {
666                        __ptr,
667                        parent,
668                        m_minForce,
669                        m_maxForce,
670                    };
671                    let __ptr = __A::class_ptr(&mut __map);
672                    _serde::__private::Ok(hkpCallbackConstraintMotor {
673                        __ptr,
674                        parent,
675                        m_callbackType,
676                        m_userData0,
677                        m_userData1,
678                        m_userData2,
679                        ..Default::default()
680                    })
681                }
682            }
683            const FIELDS: &[&str] = &[
684                "callbackFunc",
685                "callbackType",
686                "userData0",
687                "userData1",
688                "userData2",
689            ];
690            _serde::Deserializer::deserialize_struct(
691                deserializer,
692                "hkpCallbackConstraintMotor",
693                FIELDS,
694                __hkpCallbackConstraintMotorVisitor {
695                    marker: _serde::__private::PhantomData::<hkpCallbackConstraintMotor>,
696                    lifetime: _serde::__private::PhantomData,
697                },
698            )
699        }
700    }
701};
702/// # C++ Info
703/// - name: `CallbackType`(ctype: `hkEnum<CallbackType, hkUint32>`)
704#[allow(non_upper_case_globals, non_snake_case)]
705#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
706#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
707#[derive(
708    Debug,
709    Clone,
710    Default,
711    PartialEq,
712    Eq,
713    PartialOrd,
714    Ord,
715    num_derive::ToPrimitive,
716    num_derive::FromPrimitive,
717)]
718pub enum CallbackType {
719    #[default]
720    CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER = 0isize,
721    CALLBACK_MOTOR_TYPE_USER_0 = 1isize,
722    CALLBACK_MOTOR_TYPE_USER_1 = 2isize,
723    CALLBACK_MOTOR_TYPE_USER_2 = 3isize,
724    CALLBACK_MOTOR_TYPE_USER_3 = 4isize,
725}
726const _: () = {
727    use havok_serde as __serde;
728    impl __serde::Serialize for CallbackType {
729        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
730        where
731            S: __serde::ser::Serializer,
732        {
733            let mut __serializer = __serializer.serialize_enum_flags()?;
734            match self {
735                Self::CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER => {
736                    __serializer
737                        .serialize_field(
738                            "CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER",
739                            &0u64,
740                        )
741                }
742                Self::CALLBACK_MOTOR_TYPE_USER_0 => {
743                    __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_0", &1u64)
744                }
745                Self::CALLBACK_MOTOR_TYPE_USER_1 => {
746                    __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_1", &2u64)
747                }
748                Self::CALLBACK_MOTOR_TYPE_USER_2 => {
749                    __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_2", &3u64)
750                }
751                Self::CALLBACK_MOTOR_TYPE_USER_3 => {
752                    __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_3", &4u64)
753                }
754            }?;
755            use num_traits::ToPrimitive as _;
756            let num = self
757                .to_u32()
758                .ok_or(S::Error::custom("Failed enum CallbackType to_u32"))?;
759            __serializer.serialize_bits(&num)?;
760            __serializer.end()
761        }
762    }
763};
764#[doc(hidden)]
765#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
766const _: () = {
767    #[allow(unused_extern_crates, clippy::useless_attribute)]
768    extern crate havok_serde as _serde;
769    #[automatically_derived]
770    impl<'de> _serde::Deserialize<'de> for CallbackType {
771        fn deserialize<__D>(
772            __deserializer: __D,
773        ) -> _serde::__private::Result<Self, __D::Error>
774        where
775            __D: _serde::Deserializer<'de>,
776        {
777            #[allow(non_camel_case_types)]
778            #[doc(hidden)]
779            enum __Field {
780                __field0,
781                __field1,
782                __field2,
783                __field3,
784                __field4,
785            }
786            #[doc(hidden)]
787            struct __FieldVisitor;
788            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
789                type Value = __Field;
790                fn expecting(
791                    &self,
792                    __formatter: &mut _serde::__private::Formatter,
793                ) -> _serde::__private::fmt::Result {
794                    _serde::__private::Formatter::write_str(
795                        __formatter,
796                        "variant identifier",
797                    )
798                }
799                fn visit_uint32<__E>(
800                    self,
801                    __value: u32,
802                ) -> _serde::__private::Result<Self::Value, __E>
803                where
804                    __E: _serde::de::Error,
805                {
806                    match __value {
807                        0u32 => _serde::__private::Ok(__Field::__field0),
808                        1u32 => _serde::__private::Ok(__Field::__field1),
809                        2u32 => _serde::__private::Ok(__Field::__field2),
810                        3u32 => _serde::__private::Ok(__Field::__field3),
811                        4u32 => _serde::__private::Ok(__Field::__field4),
812                        _ => {
813                            _serde::__private::Err(
814                                _serde::de::Error::invalid_value(
815                                    _serde::de::Unexpected::Uint32(__value),
816                                    &"value(u32) of variant is one of 0, 1, 2, 3, 4",
817                                ),
818                            )
819                        }
820                    }
821                }
822                fn visit_stringptr<__E>(
823                    self,
824                    __value: StringPtr<'de>,
825                ) -> _serde::__private::Result<Self::Value, __E>
826                where
827                    __E: _serde::de::Error,
828                {
829                    if let Some(__value) = __value.into_inner() {
830                        match __value.as_ref() {
831                            v if v == "0"
832                                || v
833                                    .eq_ignore_ascii_case(
834                                        "CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER",
835                                    ) => _serde::__private::Ok(__Field::__field0),
836                            v if v == "1"
837                                || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_0") => {
838                                _serde::__private::Ok(__Field::__field1)
839                            }
840                            v if v == "2"
841                                || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_1") => {
842                                _serde::__private::Ok(__Field::__field2)
843                            }
844                            v if v == "3"
845                                || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_2") => {
846                                _serde::__private::Ok(__Field::__field3)
847                            }
848                            v if v == "4"
849                                || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_3") => {
850                                _serde::__private::Ok(__Field::__field4)
851                            }
852                            _ => {
853                                _serde::__private::Err(
854                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
855                                )
856                            }
857                        }
858                    } else {
859                        _serde::__private::Err(
860                            _serde::de::Error::unknown_variant("None", VARIANTS),
861                        )
862                    }
863                }
864            }
865            impl<'de> _serde::Deserialize<'de> for __Field {
866                #[inline]
867                fn deserialize<__D>(
868                    __deserializer: __D,
869                ) -> _serde::__private::Result<Self, __D::Error>
870                where
871                    __D: _serde::Deserializer<'de>,
872                {
873                    _serde::Deserializer::deserialize_identifier(
874                        __deserializer,
875                        _serde::de::ReadEnumSize::Uint32,
876                        __FieldVisitor,
877                    )
878                }
879            }
880            #[doc(hidden)]
881            struct __Visitor<'de> {
882                marker: _serde::__private::PhantomData<CallbackType>,
883                lifetime: _serde::__private::PhantomData<&'de ()>,
884            }
885            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
886                type Value = CallbackType;
887                fn expecting(
888                    &self,
889                    __formatter: &mut _serde::__private::Formatter,
890                ) -> _serde::__private::fmt::Result {
891                    _serde::__private::Formatter::write_str(
892                        __formatter,
893                        "enum CallbackType",
894                    )
895                }
896                fn visit_enum<__A>(
897                    self,
898                    __data: __A,
899                ) -> _serde::__private::Result<Self::Value, __A::Error>
900                where
901                    __A: _serde::de::EnumAccess<'de>,
902                {
903                    match _serde::de::EnumAccess::variant(__data)? {
904                        (__Field::__field0, __variant) => {
905                            _serde::de::VariantAccess::unit_variant(__variant)?;
906                            _serde::__private::Ok(
907                                CallbackType::CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER,
908                            )
909                        }
910                        (__Field::__field1, __variant) => {
911                            _serde::de::VariantAccess::unit_variant(__variant)?;
912                            _serde::__private::Ok(
913                                CallbackType::CALLBACK_MOTOR_TYPE_USER_0,
914                            )
915                        }
916                        (__Field::__field2, __variant) => {
917                            _serde::de::VariantAccess::unit_variant(__variant)?;
918                            _serde::__private::Ok(
919                                CallbackType::CALLBACK_MOTOR_TYPE_USER_1,
920                            )
921                        }
922                        (__Field::__field3, __variant) => {
923                            _serde::de::VariantAccess::unit_variant(__variant)?;
924                            _serde::__private::Ok(
925                                CallbackType::CALLBACK_MOTOR_TYPE_USER_2,
926                            )
927                        }
928                        (__Field::__field4, __variant) => {
929                            _serde::de::VariantAccess::unit_variant(__variant)?;
930                            _serde::__private::Ok(
931                                CallbackType::CALLBACK_MOTOR_TYPE_USER_3,
932                            )
933                        }
934                    }
935                }
936            }
937            #[doc(hidden)]
938            const VARIANTS: &'static [&'static str] = &[
939                "CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER",
940                "CALLBACK_MOTOR_TYPE_USER_0",
941                "CALLBACK_MOTOR_TYPE_USER_1",
942                "CALLBACK_MOTOR_TYPE_USER_2",
943                "CALLBACK_MOTOR_TYPE_USER_3",
944            ];
945            _serde::Deserializer::deserialize_enum(
946                __deserializer,
947                "CallbackType",
948                VARIANTS,
949                __Visitor {
950                    marker: _serde::__private::PhantomData::<CallbackType>,
951                    lifetime: _serde::__private::PhantomData,
952                },
953            )
954        }
955    }
956};