havok_classes/generated/
hkbTransformVectorModifier_.rs

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