havok_classes/generated/
BSTweenerModifier_.rs

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