havok_classes/generated/
hkbCombineTransformsModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbCombineTransformsModifier`
5/// - version: `0`
6/// - signature: `0xfd1f0b79`
7/// - size: `160`(x86)/`192`(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 hkbCombineTransformsModifier<'a> {
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    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkbModifier<'a>,
31    /// # C++ Info
32    /// - name: `translationOut`(ctype: `hkVector4`)
33    /// - offset: ` 48`(x86)/` 80`(x86_64)
34    /// - type_size: ` 16`(x86)/` 16`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "translationOut"))]
36    #[cfg_attr(feature = "serde", serde(rename = "translationOut"))]
37    pub m_translationOut: Vector4,
38    /// # C++ Info
39    /// - name: `rotationOut`(ctype: `hkQuaternion`)
40    /// - offset: ` 64`(x86)/` 96`(x86_64)
41    /// - type_size: ` 16`(x86)/` 16`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "rotationOut"))]
43    #[cfg_attr(feature = "serde", serde(rename = "rotationOut"))]
44    pub m_rotationOut: Quaternion,
45    /// # C++ Info
46    /// - name: `leftTranslation`(ctype: `hkVector4`)
47    /// - offset: ` 80`(x86)/`112`(x86_64)
48    /// - type_size: ` 16`(x86)/` 16`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "leftTranslation"))]
50    #[cfg_attr(feature = "serde", serde(rename = "leftTranslation"))]
51    pub m_leftTranslation: Vector4,
52    /// # C++ Info
53    /// - name: `leftRotation`(ctype: `hkQuaternion`)
54    /// - offset: ` 96`(x86)/`128`(x86_64)
55    /// - type_size: ` 16`(x86)/` 16`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "leftRotation"))]
57    #[cfg_attr(feature = "serde", serde(rename = "leftRotation"))]
58    pub m_leftRotation: Quaternion,
59    /// # C++ Info
60    /// - name: `rightTranslation`(ctype: `hkVector4`)
61    /// - offset: `112`(x86)/`144`(x86_64)
62    /// - type_size: ` 16`(x86)/` 16`(x86_64)
63    #[cfg_attr(feature = "json_schema", schemars(rename = "rightTranslation"))]
64    #[cfg_attr(feature = "serde", serde(rename = "rightTranslation"))]
65    pub m_rightTranslation: Vector4,
66    /// # C++ Info
67    /// - name: `rightRotation`(ctype: `hkQuaternion`)
68    /// - offset: `128`(x86)/`160`(x86_64)
69    /// - type_size: ` 16`(x86)/` 16`(x86_64)
70    #[cfg_attr(feature = "json_schema", schemars(rename = "rightRotation"))]
71    #[cfg_attr(feature = "serde", serde(rename = "rightRotation"))]
72    pub m_rightRotation: Quaternion,
73    /// # C++ Info
74    /// - name: `invertLeftTransform`(ctype: `hkBool`)
75    /// - offset: `144`(x86)/`176`(x86_64)
76    /// - type_size: `  1`(x86)/`  1`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "invertLeftTransform"))]
78    #[cfg_attr(feature = "serde", serde(rename = "invertLeftTransform"))]
79    pub m_invertLeftTransform: bool,
80    /// # C++ Info
81    /// - name: `invertRightTransform`(ctype: `hkBool`)
82    /// - offset: `145`(x86)/`177`(x86_64)
83    /// - type_size: `  1`(x86)/`  1`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "invertRightTransform"))]
85    #[cfg_attr(feature = "serde", serde(rename = "invertRightTransform"))]
86    pub m_invertRightTransform: bool,
87    /// # C++ Info
88    /// - name: `invertResult`(ctype: `hkBool`)
89    /// - offset: `146`(x86)/`178`(x86_64)
90    /// - type_size: `  1`(x86)/`  1`(x86_64)
91    #[cfg_attr(feature = "json_schema", schemars(rename = "invertResult"))]
92    #[cfg_attr(feature = "serde", serde(rename = "invertResult"))]
93    pub m_invertResult: bool,
94}
95const _: () = {
96    use havok_serde as _serde;
97    impl<'a> _serde::HavokClass for hkbCombineTransformsModifier<'a> {
98        #[inline]
99        fn name(&self) -> &'static str {
100            "hkbCombineTransformsModifier"
101        }
102        #[inline]
103        fn signature(&self) -> _serde::__private::Signature {
104            _serde::__private::Signature::new(0xfd1f0b79)
105        }
106        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
107        fn deps_indexes(&self) -> Vec<usize> {
108            let mut v = Vec::new();
109            v.push(self.parent.parent.parent.m_variableBindingSet.get());
110            v
111        }
112    }
113    impl<'a> _serde::Serialize for hkbCombineTransformsModifier<'a> {
114        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
115        where
116            S: _serde::ser::Serializer,
117        {
118            let class_meta = self
119                .__ptr
120                .map(|name| (name, _serde::__private::Signature::new(0xfd1f0b79)));
121            let mut serializer = __serializer
122                .serialize_struct(
123                    "hkbCombineTransformsModifier",
124                    class_meta,
125                    (160u64, 192u64),
126                )?;
127            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
128            serializer
129                .skip_field(
130                    "memSizeAndFlags",
131                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
132                )?;
133            serializer
134                .skip_field(
135                    "referenceCount",
136                    &self.parent.parent.parent.parent.m_referenceCount,
137                )?;
138            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
139            serializer
140                .serialize_field(
141                    "variableBindingSet",
142                    &self.parent.parent.parent.m_variableBindingSet,
143                )?;
144            serializer
145                .skip_array_field(
146                    "cachedBindables",
147                    &self.parent.parent.parent.m_cachedBindables,
148                    TypeSize::NonPtr,
149                )?;
150            serializer
151                .skip_field(
152                    "areBindablesCached",
153                    &self.parent.parent.parent.m_areBindablesCached,
154                )?;
155            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
156            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
157            serializer.serialize_field("name", &self.parent.parent.m_name)?;
158            serializer.skip_field("id", &self.parent.parent.m_id)?;
159            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
160            serializer
161                .skip_fixed_array_field(
162                    "padNode",
163                    self.parent.parent.m_padNode.as_slice(),
164                    TypeSize::NonPtr,
165                )?;
166            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
167            serializer.serialize_field("enable", &self.parent.m_enable)?;
168            serializer
169                .skip_fixed_array_field(
170                    "padModifier",
171                    self.parent.m_padModifier.as_slice(),
172                    TypeSize::NonPtr,
173                )?;
174            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
175            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
176            serializer.serialize_field("translationOut", &self.m_translationOut)?;
177            serializer.serialize_field("rotationOut", &self.m_rotationOut)?;
178            serializer.serialize_field("leftTranslation", &self.m_leftTranslation)?;
179            serializer.serialize_field("leftRotation", &self.m_leftRotation)?;
180            serializer.serialize_field("rightTranslation", &self.m_rightTranslation)?;
181            serializer.serialize_field("rightRotation", &self.m_rightRotation)?;
182            serializer
183                .serialize_field("invertLeftTransform", &self.m_invertLeftTransform)?;
184            serializer
185                .serialize_field("invertRightTransform", &self.m_invertRightTransform)?;
186            serializer.serialize_field("invertResult", &self.m_invertResult)?;
187            serializer.pad_field([0u8; 13usize].as_slice(), [0u8; 13usize].as_slice())?;
188            serializer.end()
189        }
190    }
191};
192#[doc(hidden)]
193#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
194const _: () = {
195    use havok_serde as _serde;
196    #[automatically_derived]
197    impl<'de> _serde::Deserialize<'de> for hkbCombineTransformsModifier<'de> {
198        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
199        where
200            __D: _serde::Deserializer<'de>,
201        {
202            #[allow(non_camel_case_types)]
203            enum __Field {
204                m_variableBindingSet,
205                m_userData,
206                m_name,
207                m_enable,
208                m_translationOut,
209                m_rotationOut,
210                m_leftTranslation,
211                m_leftRotation,
212                m_rightTranslation,
213                m_rightRotation,
214                m_invertLeftTransform,
215                m_invertRightTransform,
216                m_invertResult,
217                __ignore,
218            }
219            struct __FieldVisitor;
220            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
221                type Value = __Field;
222                fn expecting(
223                    &self,
224                    __formatter: &mut core::fmt::Formatter,
225                ) -> core::fmt::Result {
226                    core::fmt::Formatter::write_str(__formatter, "field identifier")
227                }
228                /// Intended for use in XML.
229                #[allow(clippy::match_single_binding)]
230                #[allow(clippy::reversed_empty_ranges)]
231                #[allow(clippy::single_match)]
232                fn visit_key<__E>(
233                    self,
234                    __value: &str,
235                ) -> core::result::Result<Self::Value, __E>
236                where
237                    __E: _serde::de::Error,
238                {
239                    match __value {
240                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
241                        "userData" => Ok(__Field::m_userData),
242                        "name" => Ok(__Field::m_name),
243                        "enable" => Ok(__Field::m_enable),
244                        "translationOut" => Ok(__Field::m_translationOut),
245                        "rotationOut" => Ok(__Field::m_rotationOut),
246                        "leftTranslation" => Ok(__Field::m_leftTranslation),
247                        "leftRotation" => Ok(__Field::m_leftRotation),
248                        "rightTranslation" => Ok(__Field::m_rightTranslation),
249                        "rightRotation" => Ok(__Field::m_rightRotation),
250                        "invertLeftTransform" => Ok(__Field::m_invertLeftTransform),
251                        "invertRightTransform" => Ok(__Field::m_invertRightTransform),
252                        "invertResult" => Ok(__Field::m_invertResult),
253                        _ => Ok(__Field::__ignore),
254                    }
255                }
256            }
257            impl<'de> _serde::Deserialize<'de> for __Field {
258                #[inline]
259                fn deserialize<__D>(
260                    __deserializer: __D,
261                ) -> core::result::Result<Self, __D::Error>
262                where
263                    __D: _serde::Deserializer<'de>,
264                {
265                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
266                }
267            }
268            struct __hkbCombineTransformsModifierVisitor<'de> {
269                marker: _serde::__private::PhantomData<
270                    hkbCombineTransformsModifier<'de>,
271                >,
272                lifetime: _serde::__private::PhantomData<&'de ()>,
273            }
274            #[allow(clippy::match_single_binding)]
275            #[allow(clippy::reversed_empty_ranges)]
276            #[allow(clippy::single_match)]
277            impl<'de> _serde::de::Visitor<'de>
278            for __hkbCombineTransformsModifierVisitor<'de> {
279                type Value = hkbCombineTransformsModifier<'de>;
280                fn expecting(
281                    &self,
282                    __formatter: &mut core::fmt::Formatter,
283                ) -> core::fmt::Result {
284                    core::fmt::Formatter::write_str(
285                        __formatter,
286                        "struct hkbCombineTransformsModifier",
287                    )
288                }
289                fn visit_struct_for_bytes<__A>(
290                    self,
291                    mut __map: __A,
292                ) -> _serde::__private::Result<Self::Value, __A::Error>
293                where
294                    __A: _serde::de::MapAccess<'de>,
295                {
296                    let __ptr = __A::class_ptr(&mut __map);
297                    let parent = __A::parent_value(&mut __map)?;
298                    let mut m_translationOut: _serde::__private::Option<Vector4> = _serde::__private::None;
299                    let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
300                    let mut m_leftTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
301                    let mut m_leftRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
302                    let mut m_rightTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
303                    let mut m_rightRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
304                    let mut m_invertLeftTransform: _serde::__private::Option<bool> = _serde::__private::None;
305                    let mut m_invertRightTransform: _serde::__private::Option<bool> = _serde::__private::None;
306                    let mut m_invertResult: _serde::__private::Option<bool> = _serde::__private::None;
307                    for i in 0..9usize {
308                        match i {
309                            0usize => {
310                                if _serde::__private::Option::is_some(&m_translationOut) {
311                                    return _serde::__private::Err(
312                                        <__A::Error as _serde::de::Error>::duplicate_field(
313                                            "translationOut",
314                                        ),
315                                    );
316                                }
317                                __A::pad(&mut __map, 4usize, 0usize)?;
318                                m_translationOut = _serde::__private::Some(
319                                    match __A::next_value::<Vector4>(&mut __map) {
320                                        _serde::__private::Ok(__val) => __val,
321                                        _serde::__private::Err(__err) => {
322                                            return _serde::__private::Err(__err);
323                                        }
324                                    },
325                                );
326                            }
327                            1usize => {
328                                if _serde::__private::Option::is_some(&m_rotationOut) {
329                                    return _serde::__private::Err(
330                                        <__A::Error as _serde::de::Error>::duplicate_field(
331                                            "rotationOut",
332                                        ),
333                                    );
334                                }
335                                m_rotationOut = _serde::__private::Some(
336                                    match __A::next_value::<Quaternion>(&mut __map) {
337                                        _serde::__private::Ok(__val) => __val,
338                                        _serde::__private::Err(__err) => {
339                                            return _serde::__private::Err(__err);
340                                        }
341                                    },
342                                );
343                            }
344                            2usize => {
345                                if _serde::__private::Option::is_some(&m_leftTranslation) {
346                                    return _serde::__private::Err(
347                                        <__A::Error as _serde::de::Error>::duplicate_field(
348                                            "leftTranslation",
349                                        ),
350                                    );
351                                }
352                                m_leftTranslation = _serde::__private::Some(
353                                    match __A::next_value::<Vector4>(&mut __map) {
354                                        _serde::__private::Ok(__val) => __val,
355                                        _serde::__private::Err(__err) => {
356                                            return _serde::__private::Err(__err);
357                                        }
358                                    },
359                                );
360                            }
361                            3usize => {
362                                if _serde::__private::Option::is_some(&m_leftRotation) {
363                                    return _serde::__private::Err(
364                                        <__A::Error as _serde::de::Error>::duplicate_field(
365                                            "leftRotation",
366                                        ),
367                                    );
368                                }
369                                m_leftRotation = _serde::__private::Some(
370                                    match __A::next_value::<Quaternion>(&mut __map) {
371                                        _serde::__private::Ok(__val) => __val,
372                                        _serde::__private::Err(__err) => {
373                                            return _serde::__private::Err(__err);
374                                        }
375                                    },
376                                );
377                            }
378                            4usize => {
379                                if _serde::__private::Option::is_some(&m_rightTranslation) {
380                                    return _serde::__private::Err(
381                                        <__A::Error as _serde::de::Error>::duplicate_field(
382                                            "rightTranslation",
383                                        ),
384                                    );
385                                }
386                                m_rightTranslation = _serde::__private::Some(
387                                    match __A::next_value::<Vector4>(&mut __map) {
388                                        _serde::__private::Ok(__val) => __val,
389                                        _serde::__private::Err(__err) => {
390                                            return _serde::__private::Err(__err);
391                                        }
392                                    },
393                                );
394                            }
395                            5usize => {
396                                if _serde::__private::Option::is_some(&m_rightRotation) {
397                                    return _serde::__private::Err(
398                                        <__A::Error as _serde::de::Error>::duplicate_field(
399                                            "rightRotation",
400                                        ),
401                                    );
402                                }
403                                m_rightRotation = _serde::__private::Some(
404                                    match __A::next_value::<Quaternion>(&mut __map) {
405                                        _serde::__private::Ok(__val) => __val,
406                                        _serde::__private::Err(__err) => {
407                                            return _serde::__private::Err(__err);
408                                        }
409                                    },
410                                );
411                            }
412                            6usize => {
413                                if _serde::__private::Option::is_some(
414                                    &m_invertLeftTransform,
415                                ) {
416                                    return _serde::__private::Err(
417                                        <__A::Error as _serde::de::Error>::duplicate_field(
418                                            "invertLeftTransform",
419                                        ),
420                                    );
421                                }
422                                m_invertLeftTransform = _serde::__private::Some(
423                                    match __A::next_value::<bool>(&mut __map) {
424                                        _serde::__private::Ok(__val) => __val,
425                                        _serde::__private::Err(__err) => {
426                                            return _serde::__private::Err(__err);
427                                        }
428                                    },
429                                );
430                            }
431                            7usize => {
432                                if _serde::__private::Option::is_some(
433                                    &m_invertRightTransform,
434                                ) {
435                                    return _serde::__private::Err(
436                                        <__A::Error as _serde::de::Error>::duplicate_field(
437                                            "invertRightTransform",
438                                        ),
439                                    );
440                                }
441                                m_invertRightTransform = _serde::__private::Some(
442                                    match __A::next_value::<bool>(&mut __map) {
443                                        _serde::__private::Ok(__val) => __val,
444                                        _serde::__private::Err(__err) => {
445                                            return _serde::__private::Err(__err);
446                                        }
447                                    },
448                                );
449                            }
450                            8usize => {
451                                if _serde::__private::Option::is_some(&m_invertResult) {
452                                    return _serde::__private::Err(
453                                        <__A::Error as _serde::de::Error>::duplicate_field(
454                                            "invertResult",
455                                        ),
456                                    );
457                                }
458                                m_invertResult = _serde::__private::Some(
459                                    match __A::next_value::<bool>(&mut __map) {
460                                        _serde::__private::Ok(__val) => __val,
461                                        _serde::__private::Err(__err) => {
462                                            return _serde::__private::Err(__err);
463                                        }
464                                    },
465                                );
466                            }
467                            _ => {}
468                        }
469                    }
470                    __A::pad(&mut __map, 13usize, 13usize)?;
471                    let m_translationOut = match m_translationOut {
472                        _serde::__private::Some(__field) => __field,
473                        _serde::__private::None => {
474                            return _serde::__private::Err(
475                                <__A::Error as _serde::de::Error>::missing_field(
476                                    "translationOut",
477                                ),
478                            );
479                        }
480                    };
481                    let m_rotationOut = match m_rotationOut {
482                        _serde::__private::Some(__field) => __field,
483                        _serde::__private::None => {
484                            return _serde::__private::Err(
485                                <__A::Error as _serde::de::Error>::missing_field(
486                                    "rotationOut",
487                                ),
488                            );
489                        }
490                    };
491                    let m_leftTranslation = match m_leftTranslation {
492                        _serde::__private::Some(__field) => __field,
493                        _serde::__private::None => {
494                            return _serde::__private::Err(
495                                <__A::Error as _serde::de::Error>::missing_field(
496                                    "leftTranslation",
497                                ),
498                            );
499                        }
500                    };
501                    let m_leftRotation = match m_leftRotation {
502                        _serde::__private::Some(__field) => __field,
503                        _serde::__private::None => {
504                            return _serde::__private::Err(
505                                <__A::Error as _serde::de::Error>::missing_field(
506                                    "leftRotation",
507                                ),
508                            );
509                        }
510                    };
511                    let m_rightTranslation = match m_rightTranslation {
512                        _serde::__private::Some(__field) => __field,
513                        _serde::__private::None => {
514                            return _serde::__private::Err(
515                                <__A::Error as _serde::de::Error>::missing_field(
516                                    "rightTranslation",
517                                ),
518                            );
519                        }
520                    };
521                    let m_rightRotation = match m_rightRotation {
522                        _serde::__private::Some(__field) => __field,
523                        _serde::__private::None => {
524                            return _serde::__private::Err(
525                                <__A::Error as _serde::de::Error>::missing_field(
526                                    "rightRotation",
527                                ),
528                            );
529                        }
530                    };
531                    let m_invertLeftTransform = match m_invertLeftTransform {
532                        _serde::__private::Some(__field) => __field,
533                        _serde::__private::None => {
534                            return _serde::__private::Err(
535                                <__A::Error as _serde::de::Error>::missing_field(
536                                    "invertLeftTransform",
537                                ),
538                            );
539                        }
540                    };
541                    let m_invertRightTransform = match m_invertRightTransform {
542                        _serde::__private::Some(__field) => __field,
543                        _serde::__private::None => {
544                            return _serde::__private::Err(
545                                <__A::Error as _serde::de::Error>::missing_field(
546                                    "invertRightTransform",
547                                ),
548                            );
549                        }
550                    };
551                    let m_invertResult = match m_invertResult {
552                        _serde::__private::Some(__field) => __field,
553                        _serde::__private::None => {
554                            return _serde::__private::Err(
555                                <__A::Error as _serde::de::Error>::missing_field(
556                                    "invertResult",
557                                ),
558                            );
559                        }
560                    };
561                    _serde::__private::Ok(hkbCombineTransformsModifier {
562                        __ptr,
563                        parent,
564                        m_translationOut,
565                        m_rotationOut,
566                        m_leftTranslation,
567                        m_leftRotation,
568                        m_rightTranslation,
569                        m_rightRotation,
570                        m_invertLeftTransform,
571                        m_invertRightTransform,
572                        m_invertResult,
573                    })
574                }
575                #[allow(clippy::manual_unwrap_or_default)]
576                fn visit_struct<__A>(
577                    self,
578                    mut __map: __A,
579                ) -> _serde::__private::Result<Self::Value, __A::Error>
580                where
581                    __A: _serde::de::MapAccess<'de>,
582                {
583                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
584                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
585                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
586                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
587                    let mut m_translationOut: _serde::__private::Option<Vector4> = _serde::__private::None;
588                    let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
589                    let mut m_leftTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
590                    let mut m_leftRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
591                    let mut m_rightTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
592                    let mut m_rightRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
593                    let mut m_invertLeftTransform: _serde::__private::Option<bool> = _serde::__private::None;
594                    let mut m_invertRightTransform: _serde::__private::Option<bool> = _serde::__private::None;
595                    let mut m_invertResult: _serde::__private::Option<bool> = _serde::__private::None;
596                    while let _serde::__private::Some(__key) = {
597                        __A::next_key::<__Field>(&mut __map)?
598                    } {
599                        match __key {
600                            __Field::m_variableBindingSet => {
601                                #[cfg(
602                                    any(feature = "strict", feature = "ignore_duplicates")
603                                )]
604                                if _serde::__private::Option::is_some(
605                                    &m_variableBindingSet,
606                                ) {
607                                    #[cfg(feature = "ignore_duplicates")]
608                                    {
609                                        __A::skip_value(&mut __map)?;
610                                        continue;
611                                    }
612                                    #[cfg(feature = "strict")]
613                                    return _serde::__private::Err(
614                                        <__A::Error as _serde::de::Error>::duplicate_field(
615                                            "variableBindingSet",
616                                        ),
617                                    );
618                                }
619                                m_variableBindingSet = _serde::__private::Some(
620                                    match __A::next_value::<Pointer>(&mut __map) {
621                                        _serde::__private::Ok(__val) => __val,
622                                        _serde::__private::Err(__err) => {
623                                            return _serde::__private::Err(__err);
624                                        }
625                                    },
626                                );
627                            }
628                            __Field::m_userData => {
629                                #[cfg(
630                                    any(feature = "strict", feature = "ignore_duplicates")
631                                )]
632                                if _serde::__private::Option::is_some(&m_userData) {
633                                    #[cfg(feature = "ignore_duplicates")]
634                                    {
635                                        __A::skip_value(&mut __map)?;
636                                        continue;
637                                    }
638                                    #[cfg(feature = "strict")]
639                                    return _serde::__private::Err(
640                                        <__A::Error as _serde::de::Error>::duplicate_field(
641                                            "userData",
642                                        ),
643                                    );
644                                }
645                                m_userData = _serde::__private::Some(
646                                    match __A::next_value::<Ulong>(&mut __map) {
647                                        _serde::__private::Ok(__val) => __val,
648                                        _serde::__private::Err(__err) => {
649                                            return _serde::__private::Err(__err);
650                                        }
651                                    },
652                                );
653                            }
654                            __Field::m_name => {
655                                #[cfg(
656                                    any(feature = "strict", feature = "ignore_duplicates")
657                                )]
658                                if _serde::__private::Option::is_some(&m_name) {
659                                    #[cfg(feature = "ignore_duplicates")]
660                                    {
661                                        __A::skip_value(&mut __map)?;
662                                        continue;
663                                    }
664                                    #[cfg(feature = "strict")]
665                                    return _serde::__private::Err(
666                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
667                                    );
668                                }
669                                m_name = _serde::__private::Some(
670                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
671                                        _serde::__private::Ok(__val) => __val,
672                                        _serde::__private::Err(__err) => {
673                                            return _serde::__private::Err(__err);
674                                        }
675                                    },
676                                );
677                            }
678                            __Field::m_enable => {
679                                #[cfg(
680                                    any(feature = "strict", feature = "ignore_duplicates")
681                                )]
682                                if _serde::__private::Option::is_some(&m_enable) {
683                                    #[cfg(feature = "ignore_duplicates")]
684                                    {
685                                        __A::skip_value(&mut __map)?;
686                                        continue;
687                                    }
688                                    #[cfg(feature = "strict")]
689                                    return _serde::__private::Err(
690                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
691                                    );
692                                }
693                                m_enable = _serde::__private::Some(
694                                    match __A::next_value::<bool>(&mut __map) {
695                                        _serde::__private::Ok(__val) => __val,
696                                        _serde::__private::Err(__err) => {
697                                            return _serde::__private::Err(__err);
698                                        }
699                                    },
700                                );
701                            }
702                            __Field::m_translationOut => {
703                                #[cfg(
704                                    any(feature = "strict", feature = "ignore_duplicates")
705                                )]
706                                if _serde::__private::Option::is_some(&m_translationOut) {
707                                    #[cfg(feature = "ignore_duplicates")]
708                                    {
709                                        __A::skip_value(&mut __map)?;
710                                        continue;
711                                    }
712                                    #[cfg(feature = "strict")]
713                                    return _serde::__private::Err(
714                                        <__A::Error as _serde::de::Error>::duplicate_field(
715                                            "translationOut",
716                                        ),
717                                    );
718                                }
719                                m_translationOut = _serde::__private::Some(
720                                    match __A::next_value::<Vector4>(&mut __map) {
721                                        _serde::__private::Ok(__val) => __val,
722                                        _serde::__private::Err(__err) => {
723                                            return _serde::__private::Err(__err);
724                                        }
725                                    },
726                                );
727                            }
728                            __Field::m_rotationOut => {
729                                #[cfg(
730                                    any(feature = "strict", feature = "ignore_duplicates")
731                                )]
732                                if _serde::__private::Option::is_some(&m_rotationOut) {
733                                    #[cfg(feature = "ignore_duplicates")]
734                                    {
735                                        __A::skip_value(&mut __map)?;
736                                        continue;
737                                    }
738                                    #[cfg(feature = "strict")]
739                                    return _serde::__private::Err(
740                                        <__A::Error as _serde::de::Error>::duplicate_field(
741                                            "rotationOut",
742                                        ),
743                                    );
744                                }
745                                m_rotationOut = _serde::__private::Some(
746                                    match __A::next_value::<Quaternion>(&mut __map) {
747                                        _serde::__private::Ok(__val) => __val,
748                                        _serde::__private::Err(__err) => {
749                                            return _serde::__private::Err(__err);
750                                        }
751                                    },
752                                );
753                            }
754                            __Field::m_leftTranslation => {
755                                #[cfg(
756                                    any(feature = "strict", feature = "ignore_duplicates")
757                                )]
758                                if _serde::__private::Option::is_some(&m_leftTranslation) {
759                                    #[cfg(feature = "ignore_duplicates")]
760                                    {
761                                        __A::skip_value(&mut __map)?;
762                                        continue;
763                                    }
764                                    #[cfg(feature = "strict")]
765                                    return _serde::__private::Err(
766                                        <__A::Error as _serde::de::Error>::duplicate_field(
767                                            "leftTranslation",
768                                        ),
769                                    );
770                                }
771                                m_leftTranslation = _serde::__private::Some(
772                                    match __A::next_value::<Vector4>(&mut __map) {
773                                        _serde::__private::Ok(__val) => __val,
774                                        _serde::__private::Err(__err) => {
775                                            return _serde::__private::Err(__err);
776                                        }
777                                    },
778                                );
779                            }
780                            __Field::m_leftRotation => {
781                                #[cfg(
782                                    any(feature = "strict", feature = "ignore_duplicates")
783                                )]
784                                if _serde::__private::Option::is_some(&m_leftRotation) {
785                                    #[cfg(feature = "ignore_duplicates")]
786                                    {
787                                        __A::skip_value(&mut __map)?;
788                                        continue;
789                                    }
790                                    #[cfg(feature = "strict")]
791                                    return _serde::__private::Err(
792                                        <__A::Error as _serde::de::Error>::duplicate_field(
793                                            "leftRotation",
794                                        ),
795                                    );
796                                }
797                                m_leftRotation = _serde::__private::Some(
798                                    match __A::next_value::<Quaternion>(&mut __map) {
799                                        _serde::__private::Ok(__val) => __val,
800                                        _serde::__private::Err(__err) => {
801                                            return _serde::__private::Err(__err);
802                                        }
803                                    },
804                                );
805                            }
806                            __Field::m_rightTranslation => {
807                                #[cfg(
808                                    any(feature = "strict", feature = "ignore_duplicates")
809                                )]
810                                if _serde::__private::Option::is_some(&m_rightTranslation) {
811                                    #[cfg(feature = "ignore_duplicates")]
812                                    {
813                                        __A::skip_value(&mut __map)?;
814                                        continue;
815                                    }
816                                    #[cfg(feature = "strict")]
817                                    return _serde::__private::Err(
818                                        <__A::Error as _serde::de::Error>::duplicate_field(
819                                            "rightTranslation",
820                                        ),
821                                    );
822                                }
823                                m_rightTranslation = _serde::__private::Some(
824                                    match __A::next_value::<Vector4>(&mut __map) {
825                                        _serde::__private::Ok(__val) => __val,
826                                        _serde::__private::Err(__err) => {
827                                            return _serde::__private::Err(__err);
828                                        }
829                                    },
830                                );
831                            }
832                            __Field::m_rightRotation => {
833                                #[cfg(
834                                    any(feature = "strict", feature = "ignore_duplicates")
835                                )]
836                                if _serde::__private::Option::is_some(&m_rightRotation) {
837                                    #[cfg(feature = "ignore_duplicates")]
838                                    {
839                                        __A::skip_value(&mut __map)?;
840                                        continue;
841                                    }
842                                    #[cfg(feature = "strict")]
843                                    return _serde::__private::Err(
844                                        <__A::Error as _serde::de::Error>::duplicate_field(
845                                            "rightRotation",
846                                        ),
847                                    );
848                                }
849                                m_rightRotation = _serde::__private::Some(
850                                    match __A::next_value::<Quaternion>(&mut __map) {
851                                        _serde::__private::Ok(__val) => __val,
852                                        _serde::__private::Err(__err) => {
853                                            return _serde::__private::Err(__err);
854                                        }
855                                    },
856                                );
857                            }
858                            __Field::m_invertLeftTransform => {
859                                #[cfg(
860                                    any(feature = "strict", feature = "ignore_duplicates")
861                                )]
862                                if _serde::__private::Option::is_some(
863                                    &m_invertLeftTransform,
864                                ) {
865                                    #[cfg(feature = "ignore_duplicates")]
866                                    {
867                                        __A::skip_value(&mut __map)?;
868                                        continue;
869                                    }
870                                    #[cfg(feature = "strict")]
871                                    return _serde::__private::Err(
872                                        <__A::Error as _serde::de::Error>::duplicate_field(
873                                            "invertLeftTransform",
874                                        ),
875                                    );
876                                }
877                                m_invertLeftTransform = _serde::__private::Some(
878                                    match __A::next_value::<bool>(&mut __map) {
879                                        _serde::__private::Ok(__val) => __val,
880                                        _serde::__private::Err(__err) => {
881                                            return _serde::__private::Err(__err);
882                                        }
883                                    },
884                                );
885                            }
886                            __Field::m_invertRightTransform => {
887                                #[cfg(
888                                    any(feature = "strict", feature = "ignore_duplicates")
889                                )]
890                                if _serde::__private::Option::is_some(
891                                    &m_invertRightTransform,
892                                ) {
893                                    #[cfg(feature = "ignore_duplicates")]
894                                    {
895                                        __A::skip_value(&mut __map)?;
896                                        continue;
897                                    }
898                                    #[cfg(feature = "strict")]
899                                    return _serde::__private::Err(
900                                        <__A::Error as _serde::de::Error>::duplicate_field(
901                                            "invertRightTransform",
902                                        ),
903                                    );
904                                }
905                                m_invertRightTransform = _serde::__private::Some(
906                                    match __A::next_value::<bool>(&mut __map) {
907                                        _serde::__private::Ok(__val) => __val,
908                                        _serde::__private::Err(__err) => {
909                                            return _serde::__private::Err(__err);
910                                        }
911                                    },
912                                );
913                            }
914                            __Field::m_invertResult => {
915                                #[cfg(
916                                    any(feature = "strict", feature = "ignore_duplicates")
917                                )]
918                                if _serde::__private::Option::is_some(&m_invertResult) {
919                                    #[cfg(feature = "ignore_duplicates")]
920                                    {
921                                        __A::skip_value(&mut __map)?;
922                                        continue;
923                                    }
924                                    #[cfg(feature = "strict")]
925                                    return _serde::__private::Err(
926                                        <__A::Error as _serde::de::Error>::duplicate_field(
927                                            "invertResult",
928                                        ),
929                                    );
930                                }
931                                m_invertResult = _serde::__private::Some(
932                                    match __A::next_value::<bool>(&mut __map) {
933                                        _serde::__private::Ok(__val) => __val,
934                                        _serde::__private::Err(__err) => {
935                                            return _serde::__private::Err(__err);
936                                        }
937                                    },
938                                );
939                            }
940                            _ => __A::skip_value(&mut __map)?,
941                        }
942                    }
943                    let m_variableBindingSet = match m_variableBindingSet {
944                        _serde::__private::Some(__field) => __field,
945                        _serde::__private::None => {
946                            #[cfg(feature = "strict")]
947                            return _serde::__private::Err(
948                                <__A::Error as _serde::de::Error>::missing_field(
949                                    "variableBindingSet",
950                                ),
951                            );
952                            #[cfg(not(feature = "strict"))] Default::default()
953                        }
954                    };
955                    let m_userData = match m_userData {
956                        _serde::__private::Some(__field) => __field,
957                        _serde::__private::None => {
958                            #[cfg(feature = "strict")]
959                            return _serde::__private::Err(
960                                <__A::Error as _serde::de::Error>::missing_field("userData"),
961                            );
962                            #[cfg(not(feature = "strict"))] Default::default()
963                        }
964                    };
965                    let m_name = match m_name {
966                        _serde::__private::Some(__field) => __field,
967                        _serde::__private::None => {
968                            #[cfg(feature = "strict")]
969                            return _serde::__private::Err(
970                                <__A::Error as _serde::de::Error>::missing_field("name"),
971                            );
972                            #[cfg(not(feature = "strict"))] Default::default()
973                        }
974                    };
975                    let m_enable = match m_enable {
976                        _serde::__private::Some(__field) => __field,
977                        _serde::__private::None => {
978                            #[cfg(feature = "strict")]
979                            return _serde::__private::Err(
980                                <__A::Error as _serde::de::Error>::missing_field("enable"),
981                            );
982                            #[cfg(not(feature = "strict"))] Default::default()
983                        }
984                    };
985                    let m_translationOut = match m_translationOut {
986                        _serde::__private::Some(__field) => __field,
987                        _serde::__private::None => {
988                            #[cfg(feature = "strict")]
989                            return _serde::__private::Err(
990                                <__A::Error as _serde::de::Error>::missing_field(
991                                    "translationOut",
992                                ),
993                            );
994                            #[cfg(not(feature = "strict"))] Default::default()
995                        }
996                    };
997                    let m_rotationOut = match m_rotationOut {
998                        _serde::__private::Some(__field) => __field,
999                        _serde::__private::None => {
1000                            #[cfg(feature = "strict")]
1001                            return _serde::__private::Err(
1002                                <__A::Error as _serde::de::Error>::missing_field(
1003                                    "rotationOut",
1004                                ),
1005                            );
1006                            #[cfg(not(feature = "strict"))] Default::default()
1007                        }
1008                    };
1009                    let m_leftTranslation = match m_leftTranslation {
1010                        _serde::__private::Some(__field) => __field,
1011                        _serde::__private::None => {
1012                            #[cfg(feature = "strict")]
1013                            return _serde::__private::Err(
1014                                <__A::Error as _serde::de::Error>::missing_field(
1015                                    "leftTranslation",
1016                                ),
1017                            );
1018                            #[cfg(not(feature = "strict"))] Default::default()
1019                        }
1020                    };
1021                    let m_leftRotation = match m_leftRotation {
1022                        _serde::__private::Some(__field) => __field,
1023                        _serde::__private::None => {
1024                            #[cfg(feature = "strict")]
1025                            return _serde::__private::Err(
1026                                <__A::Error as _serde::de::Error>::missing_field(
1027                                    "leftRotation",
1028                                ),
1029                            );
1030                            #[cfg(not(feature = "strict"))] Default::default()
1031                        }
1032                    };
1033                    let m_rightTranslation = match m_rightTranslation {
1034                        _serde::__private::Some(__field) => __field,
1035                        _serde::__private::None => {
1036                            #[cfg(feature = "strict")]
1037                            return _serde::__private::Err(
1038                                <__A::Error as _serde::de::Error>::missing_field(
1039                                    "rightTranslation",
1040                                ),
1041                            );
1042                            #[cfg(not(feature = "strict"))] Default::default()
1043                        }
1044                    };
1045                    let m_rightRotation = match m_rightRotation {
1046                        _serde::__private::Some(__field) => __field,
1047                        _serde::__private::None => {
1048                            #[cfg(feature = "strict")]
1049                            return _serde::__private::Err(
1050                                <__A::Error as _serde::de::Error>::missing_field(
1051                                    "rightRotation",
1052                                ),
1053                            );
1054                            #[cfg(not(feature = "strict"))] Default::default()
1055                        }
1056                    };
1057                    let m_invertLeftTransform = match m_invertLeftTransform {
1058                        _serde::__private::Some(__field) => __field,
1059                        _serde::__private::None => {
1060                            #[cfg(feature = "strict")]
1061                            return _serde::__private::Err(
1062                                <__A::Error as _serde::de::Error>::missing_field(
1063                                    "invertLeftTransform",
1064                                ),
1065                            );
1066                            #[cfg(not(feature = "strict"))] Default::default()
1067                        }
1068                    };
1069                    let m_invertRightTransform = match m_invertRightTransform {
1070                        _serde::__private::Some(__field) => __field,
1071                        _serde::__private::None => {
1072                            #[cfg(feature = "strict")]
1073                            return _serde::__private::Err(
1074                                <__A::Error as _serde::de::Error>::missing_field(
1075                                    "invertRightTransform",
1076                                ),
1077                            );
1078                            #[cfg(not(feature = "strict"))] Default::default()
1079                        }
1080                    };
1081                    let m_invertResult = match m_invertResult {
1082                        _serde::__private::Some(__field) => __field,
1083                        _serde::__private::None => {
1084                            #[cfg(feature = "strict")]
1085                            return _serde::__private::Err(
1086                                <__A::Error as _serde::de::Error>::missing_field(
1087                                    "invertResult",
1088                                ),
1089                            );
1090                            #[cfg(not(feature = "strict"))] Default::default()
1091                        }
1092                    };
1093                    let __ptr = None;
1094                    let parent = hkBaseObject { __ptr };
1095                    let parent = hkReferencedObject {
1096                        __ptr,
1097                        parent,
1098                        ..Default::default()
1099                    };
1100                    let parent = hkbBindable {
1101                        __ptr,
1102                        parent,
1103                        m_variableBindingSet,
1104                        ..Default::default()
1105                    };
1106                    let parent = hkbNode {
1107                        __ptr,
1108                        parent,
1109                        m_userData,
1110                        m_name,
1111                        ..Default::default()
1112                    };
1113                    let parent = hkbModifier {
1114                        __ptr,
1115                        parent,
1116                        m_enable,
1117                        ..Default::default()
1118                    };
1119                    let __ptr = __A::class_ptr(&mut __map);
1120                    _serde::__private::Ok(hkbCombineTransformsModifier {
1121                        __ptr,
1122                        parent,
1123                        m_translationOut,
1124                        m_rotationOut,
1125                        m_leftTranslation,
1126                        m_leftRotation,
1127                        m_rightTranslation,
1128                        m_rightRotation,
1129                        m_invertLeftTransform,
1130                        m_invertRightTransform,
1131                        m_invertResult,
1132                    })
1133                }
1134            }
1135            const FIELDS: &[&str] = &[
1136                "translationOut",
1137                "rotationOut",
1138                "leftTranslation",
1139                "leftRotation",
1140                "rightTranslation",
1141                "rightRotation",
1142                "invertLeftTransform",
1143                "invertRightTransform",
1144                "invertResult",
1145            ];
1146            _serde::Deserializer::deserialize_struct(
1147                deserializer,
1148                "hkbCombineTransformsModifier",
1149                FIELDS,
1150                __hkbCombineTransformsModifierVisitor {
1151                    marker: _serde::__private::PhantomData::<
1152                        hkbCombineTransformsModifier,
1153                    >,
1154                    lifetime: _serde::__private::PhantomData,
1155                },
1156            )
1157        }
1158    }
1159};