havok_classes/generated/
hkbComputeRotationToTargetModifier_.rs

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