havok_classes/generated/
hkbComputeRotationFromAxisAngleModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbComputeRotationFromAxisAngleModifier`
5/// - version: `0`
6/// - signature: `0x9b3f6936`
7/// - size: ` 96`(x86)/`128`(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 hkbComputeRotationFromAxisAngleModifier<'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: `axis`(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 = "axis"))]
43    #[cfg_attr(feature = "serde", serde(rename = "axis"))]
44    pub m_axis: Vector4,
45    /// # C++ Info
46    /// - name: `angleDegrees`(ctype: `hkReal`)
47    /// - offset: ` 80`(x86)/`112`(x86_64)
48    /// - type_size: `  4`(x86)/`  4`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "angleDegrees"))]
50    #[cfg_attr(feature = "serde", serde(rename = "angleDegrees"))]
51    pub m_angleDegrees: f32,
52}
53const _: () = {
54    use havok_serde as _serde;
55    impl<'a> _serde::HavokClass for hkbComputeRotationFromAxisAngleModifier<'a> {
56        #[inline]
57        fn name(&self) -> &'static str {
58            "hkbComputeRotationFromAxisAngleModifier"
59        }
60        #[inline]
61        fn signature(&self) -> _serde::__private::Signature {
62            _serde::__private::Signature::new(0x9b3f6936)
63        }
64        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
65        fn deps_indexes(&self) -> Vec<usize> {
66            let mut v = Vec::new();
67            v.push(self.parent.parent.parent.m_variableBindingSet.get());
68            v
69        }
70    }
71    impl<'a> _serde::Serialize for hkbComputeRotationFromAxisAngleModifier<'a> {
72        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
73        where
74            S: _serde::ser::Serializer,
75        {
76            let class_meta = self
77                .__ptr
78                .map(|name| (name, _serde::__private::Signature::new(0x9b3f6936)));
79            let mut serializer = __serializer
80                .serialize_struct(
81                    "hkbComputeRotationFromAxisAngleModifier",
82                    class_meta,
83                    (96u64, 128u64),
84                )?;
85            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
86            serializer
87                .skip_field(
88                    "memSizeAndFlags",
89                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
90                )?;
91            serializer
92                .skip_field(
93                    "referenceCount",
94                    &self.parent.parent.parent.parent.m_referenceCount,
95                )?;
96            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
97            serializer
98                .serialize_field(
99                    "variableBindingSet",
100                    &self.parent.parent.parent.m_variableBindingSet,
101                )?;
102            serializer
103                .skip_array_field(
104                    "cachedBindables",
105                    &self.parent.parent.parent.m_cachedBindables,
106                    TypeSize::NonPtr,
107                )?;
108            serializer
109                .skip_field(
110                    "areBindablesCached",
111                    &self.parent.parent.parent.m_areBindablesCached,
112                )?;
113            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
114            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
115            serializer.serialize_field("name", &self.parent.parent.m_name)?;
116            serializer.skip_field("id", &self.parent.parent.m_id)?;
117            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
118            serializer
119                .skip_fixed_array_field(
120                    "padNode",
121                    self.parent.parent.m_padNode.as_slice(),
122                    TypeSize::NonPtr,
123                )?;
124            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
125            serializer.serialize_field("enable", &self.parent.m_enable)?;
126            serializer
127                .skip_fixed_array_field(
128                    "padModifier",
129                    self.parent.m_padModifier.as_slice(),
130                    TypeSize::NonPtr,
131                )?;
132            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
133            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
134            serializer.serialize_field("rotationOut", &self.m_rotationOut)?;
135            serializer.serialize_field("axis", &self.m_axis)?;
136            serializer.serialize_field("angleDegrees", &self.m_angleDegrees)?;
137            serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 12usize].as_slice())?;
138            serializer.end()
139        }
140    }
141};
142#[doc(hidden)]
143#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
144const _: () = {
145    use havok_serde as _serde;
146    #[automatically_derived]
147    impl<'de> _serde::Deserialize<'de> for hkbComputeRotationFromAxisAngleModifier<'de> {
148        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
149        where
150            __D: _serde::Deserializer<'de>,
151        {
152            #[allow(non_camel_case_types)]
153            enum __Field {
154                m_variableBindingSet,
155                m_userData,
156                m_name,
157                m_enable,
158                m_rotationOut,
159                m_axis,
160                m_angleDegrees,
161                __ignore,
162            }
163            struct __FieldVisitor;
164            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
165                type Value = __Field;
166                fn expecting(
167                    &self,
168                    __formatter: &mut core::fmt::Formatter,
169                ) -> core::fmt::Result {
170                    core::fmt::Formatter::write_str(__formatter, "field identifier")
171                }
172                /// Intended for use in XML.
173                #[allow(clippy::match_single_binding)]
174                #[allow(clippy::reversed_empty_ranges)]
175                #[allow(clippy::single_match)]
176                fn visit_key<__E>(
177                    self,
178                    __value: &str,
179                ) -> core::result::Result<Self::Value, __E>
180                where
181                    __E: _serde::de::Error,
182                {
183                    match __value {
184                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
185                        "userData" => Ok(__Field::m_userData),
186                        "name" => Ok(__Field::m_name),
187                        "enable" => Ok(__Field::m_enable),
188                        "rotationOut" => Ok(__Field::m_rotationOut),
189                        "axis" => Ok(__Field::m_axis),
190                        "angleDegrees" => Ok(__Field::m_angleDegrees),
191                        _ => Ok(__Field::__ignore),
192                    }
193                }
194            }
195            impl<'de> _serde::Deserialize<'de> for __Field {
196                #[inline]
197                fn deserialize<__D>(
198                    __deserializer: __D,
199                ) -> core::result::Result<Self, __D::Error>
200                where
201                    __D: _serde::Deserializer<'de>,
202                {
203                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
204                }
205            }
206            struct __hkbComputeRotationFromAxisAngleModifierVisitor<'de> {
207                marker: _serde::__private::PhantomData<
208                    hkbComputeRotationFromAxisAngleModifier<'de>,
209                >,
210                lifetime: _serde::__private::PhantomData<&'de ()>,
211            }
212            #[allow(clippy::match_single_binding)]
213            #[allow(clippy::reversed_empty_ranges)]
214            #[allow(clippy::single_match)]
215            impl<'de> _serde::de::Visitor<'de>
216            for __hkbComputeRotationFromAxisAngleModifierVisitor<'de> {
217                type Value = hkbComputeRotationFromAxisAngleModifier<'de>;
218                fn expecting(
219                    &self,
220                    __formatter: &mut core::fmt::Formatter,
221                ) -> core::fmt::Result {
222                    core::fmt::Formatter::write_str(
223                        __formatter,
224                        "struct hkbComputeRotationFromAxisAngleModifier",
225                    )
226                }
227                fn visit_struct_for_bytes<__A>(
228                    self,
229                    mut __map: __A,
230                ) -> _serde::__private::Result<Self::Value, __A::Error>
231                where
232                    __A: _serde::de::MapAccess<'de>,
233                {
234                    let __ptr = __A::class_ptr(&mut __map);
235                    let parent = __A::parent_value(&mut __map)?;
236                    let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
237                    let mut m_axis: _serde::__private::Option<Vector4> = _serde::__private::None;
238                    let mut m_angleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
239                    for i in 0..3usize {
240                        match i {
241                            0usize => {
242                                if _serde::__private::Option::is_some(&m_rotationOut) {
243                                    return _serde::__private::Err(
244                                        <__A::Error as _serde::de::Error>::duplicate_field(
245                                            "rotationOut",
246                                        ),
247                                    );
248                                }
249                                __A::pad(&mut __map, 4usize, 0usize)?;
250                                m_rotationOut = _serde::__private::Some(
251                                    match __A::next_value::<Quaternion>(&mut __map) {
252                                        _serde::__private::Ok(__val) => __val,
253                                        _serde::__private::Err(__err) => {
254                                            return _serde::__private::Err(__err);
255                                        }
256                                    },
257                                );
258                            }
259                            1usize => {
260                                if _serde::__private::Option::is_some(&m_axis) {
261                                    return _serde::__private::Err(
262                                        <__A::Error as _serde::de::Error>::duplicate_field("axis"),
263                                    );
264                                }
265                                m_axis = _serde::__private::Some(
266                                    match __A::next_value::<Vector4>(&mut __map) {
267                                        _serde::__private::Ok(__val) => __val,
268                                        _serde::__private::Err(__err) => {
269                                            return _serde::__private::Err(__err);
270                                        }
271                                    },
272                                );
273                            }
274                            2usize => {
275                                if _serde::__private::Option::is_some(&m_angleDegrees) {
276                                    return _serde::__private::Err(
277                                        <__A::Error as _serde::de::Error>::duplicate_field(
278                                            "angleDegrees",
279                                        ),
280                                    );
281                                }
282                                m_angleDegrees = _serde::__private::Some(
283                                    match __A::next_value::<f32>(&mut __map) {
284                                        _serde::__private::Ok(__val) => __val,
285                                        _serde::__private::Err(__err) => {
286                                            return _serde::__private::Err(__err);
287                                        }
288                                    },
289                                );
290                            }
291                            _ => {}
292                        }
293                    }
294                    __A::pad(&mut __map, 12usize, 12usize)?;
295                    let m_rotationOut = match m_rotationOut {
296                        _serde::__private::Some(__field) => __field,
297                        _serde::__private::None => {
298                            return _serde::__private::Err(
299                                <__A::Error as _serde::de::Error>::missing_field(
300                                    "rotationOut",
301                                ),
302                            );
303                        }
304                    };
305                    let m_axis = match m_axis {
306                        _serde::__private::Some(__field) => __field,
307                        _serde::__private::None => {
308                            return _serde::__private::Err(
309                                <__A::Error as _serde::de::Error>::missing_field("axis"),
310                            );
311                        }
312                    };
313                    let m_angleDegrees = match m_angleDegrees {
314                        _serde::__private::Some(__field) => __field,
315                        _serde::__private::None => {
316                            return _serde::__private::Err(
317                                <__A::Error as _serde::de::Error>::missing_field(
318                                    "angleDegrees",
319                                ),
320                            );
321                        }
322                    };
323                    _serde::__private::Ok(hkbComputeRotationFromAxisAngleModifier {
324                        __ptr,
325                        parent,
326                        m_rotationOut,
327                        m_axis,
328                        m_angleDegrees,
329                    })
330                }
331                #[allow(clippy::manual_unwrap_or_default)]
332                fn visit_struct<__A>(
333                    self,
334                    mut __map: __A,
335                ) -> _serde::__private::Result<Self::Value, __A::Error>
336                where
337                    __A: _serde::de::MapAccess<'de>,
338                {
339                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
340                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
341                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
342                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
343                    let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
344                    let mut m_axis: _serde::__private::Option<Vector4> = _serde::__private::None;
345                    let mut m_angleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
346                    while let _serde::__private::Some(__key) = {
347                        __A::next_key::<__Field>(&mut __map)?
348                    } {
349                        match __key {
350                            __Field::m_variableBindingSet => {
351                                #[cfg(
352                                    any(feature = "strict", feature = "ignore_duplicates")
353                                )]
354                                if _serde::__private::Option::is_some(
355                                    &m_variableBindingSet,
356                                ) {
357                                    #[cfg(feature = "ignore_duplicates")]
358                                    {
359                                        __A::skip_value(&mut __map)?;
360                                        continue;
361                                    }
362                                    #[cfg(feature = "strict")]
363                                    return _serde::__private::Err(
364                                        <__A::Error as _serde::de::Error>::duplicate_field(
365                                            "variableBindingSet",
366                                        ),
367                                    );
368                                }
369                                m_variableBindingSet = _serde::__private::Some(
370                                    match __A::next_value::<Pointer>(&mut __map) {
371                                        _serde::__private::Ok(__val) => __val,
372                                        _serde::__private::Err(__err) => {
373                                            return _serde::__private::Err(__err);
374                                        }
375                                    },
376                                );
377                            }
378                            __Field::m_userData => {
379                                #[cfg(
380                                    any(feature = "strict", feature = "ignore_duplicates")
381                                )]
382                                if _serde::__private::Option::is_some(&m_userData) {
383                                    #[cfg(feature = "ignore_duplicates")]
384                                    {
385                                        __A::skip_value(&mut __map)?;
386                                        continue;
387                                    }
388                                    #[cfg(feature = "strict")]
389                                    return _serde::__private::Err(
390                                        <__A::Error as _serde::de::Error>::duplicate_field(
391                                            "userData",
392                                        ),
393                                    );
394                                }
395                                m_userData = _serde::__private::Some(
396                                    match __A::next_value::<Ulong>(&mut __map) {
397                                        _serde::__private::Ok(__val) => __val,
398                                        _serde::__private::Err(__err) => {
399                                            return _serde::__private::Err(__err);
400                                        }
401                                    },
402                                );
403                            }
404                            __Field::m_name => {
405                                #[cfg(
406                                    any(feature = "strict", feature = "ignore_duplicates")
407                                )]
408                                if _serde::__private::Option::is_some(&m_name) {
409                                    #[cfg(feature = "ignore_duplicates")]
410                                    {
411                                        __A::skip_value(&mut __map)?;
412                                        continue;
413                                    }
414                                    #[cfg(feature = "strict")]
415                                    return _serde::__private::Err(
416                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
417                                    );
418                                }
419                                m_name = _serde::__private::Some(
420                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
421                                        _serde::__private::Ok(__val) => __val,
422                                        _serde::__private::Err(__err) => {
423                                            return _serde::__private::Err(__err);
424                                        }
425                                    },
426                                );
427                            }
428                            __Field::m_enable => {
429                                #[cfg(
430                                    any(feature = "strict", feature = "ignore_duplicates")
431                                )]
432                                if _serde::__private::Option::is_some(&m_enable) {
433                                    #[cfg(feature = "ignore_duplicates")]
434                                    {
435                                        __A::skip_value(&mut __map)?;
436                                        continue;
437                                    }
438                                    #[cfg(feature = "strict")]
439                                    return _serde::__private::Err(
440                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
441                                    );
442                                }
443                                m_enable = _serde::__private::Some(
444                                    match __A::next_value::<bool>(&mut __map) {
445                                        _serde::__private::Ok(__val) => __val,
446                                        _serde::__private::Err(__err) => {
447                                            return _serde::__private::Err(__err);
448                                        }
449                                    },
450                                );
451                            }
452                            __Field::m_rotationOut => {
453                                #[cfg(
454                                    any(feature = "strict", feature = "ignore_duplicates")
455                                )]
456                                if _serde::__private::Option::is_some(&m_rotationOut) {
457                                    #[cfg(feature = "ignore_duplicates")]
458                                    {
459                                        __A::skip_value(&mut __map)?;
460                                        continue;
461                                    }
462                                    #[cfg(feature = "strict")]
463                                    return _serde::__private::Err(
464                                        <__A::Error as _serde::de::Error>::duplicate_field(
465                                            "rotationOut",
466                                        ),
467                                    );
468                                }
469                                m_rotationOut = _serde::__private::Some(
470                                    match __A::next_value::<Quaternion>(&mut __map) {
471                                        _serde::__private::Ok(__val) => __val,
472                                        _serde::__private::Err(__err) => {
473                                            return _serde::__private::Err(__err);
474                                        }
475                                    },
476                                );
477                            }
478                            __Field::m_axis => {
479                                #[cfg(
480                                    any(feature = "strict", feature = "ignore_duplicates")
481                                )]
482                                if _serde::__private::Option::is_some(&m_axis) {
483                                    #[cfg(feature = "ignore_duplicates")]
484                                    {
485                                        __A::skip_value(&mut __map)?;
486                                        continue;
487                                    }
488                                    #[cfg(feature = "strict")]
489                                    return _serde::__private::Err(
490                                        <__A::Error as _serde::de::Error>::duplicate_field("axis"),
491                                    );
492                                }
493                                m_axis = _serde::__private::Some(
494                                    match __A::next_value::<Vector4>(&mut __map) {
495                                        _serde::__private::Ok(__val) => __val,
496                                        _serde::__private::Err(__err) => {
497                                            return _serde::__private::Err(__err);
498                                        }
499                                    },
500                                );
501                            }
502                            __Field::m_angleDegrees => {
503                                #[cfg(
504                                    any(feature = "strict", feature = "ignore_duplicates")
505                                )]
506                                if _serde::__private::Option::is_some(&m_angleDegrees) {
507                                    #[cfg(feature = "ignore_duplicates")]
508                                    {
509                                        __A::skip_value(&mut __map)?;
510                                        continue;
511                                    }
512                                    #[cfg(feature = "strict")]
513                                    return _serde::__private::Err(
514                                        <__A::Error as _serde::de::Error>::duplicate_field(
515                                            "angleDegrees",
516                                        ),
517                                    );
518                                }
519                                m_angleDegrees = _serde::__private::Some(
520                                    match __A::next_value::<f32>(&mut __map) {
521                                        _serde::__private::Ok(__val) => __val,
522                                        _serde::__private::Err(__err) => {
523                                            return _serde::__private::Err(__err);
524                                        }
525                                    },
526                                );
527                            }
528                            _ => __A::skip_value(&mut __map)?,
529                        }
530                    }
531                    let m_variableBindingSet = match m_variableBindingSet {
532                        _serde::__private::Some(__field) => __field,
533                        _serde::__private::None => {
534                            #[cfg(feature = "strict")]
535                            return _serde::__private::Err(
536                                <__A::Error as _serde::de::Error>::missing_field(
537                                    "variableBindingSet",
538                                ),
539                            );
540                            #[cfg(not(feature = "strict"))] Default::default()
541                        }
542                    };
543                    let m_userData = match m_userData {
544                        _serde::__private::Some(__field) => __field,
545                        _serde::__private::None => {
546                            #[cfg(feature = "strict")]
547                            return _serde::__private::Err(
548                                <__A::Error as _serde::de::Error>::missing_field("userData"),
549                            );
550                            #[cfg(not(feature = "strict"))] Default::default()
551                        }
552                    };
553                    let m_name = match m_name {
554                        _serde::__private::Some(__field) => __field,
555                        _serde::__private::None => {
556                            #[cfg(feature = "strict")]
557                            return _serde::__private::Err(
558                                <__A::Error as _serde::de::Error>::missing_field("name"),
559                            );
560                            #[cfg(not(feature = "strict"))] Default::default()
561                        }
562                    };
563                    let m_enable = match m_enable {
564                        _serde::__private::Some(__field) => __field,
565                        _serde::__private::None => {
566                            #[cfg(feature = "strict")]
567                            return _serde::__private::Err(
568                                <__A::Error as _serde::de::Error>::missing_field("enable"),
569                            );
570                            #[cfg(not(feature = "strict"))] Default::default()
571                        }
572                    };
573                    let m_rotationOut = match m_rotationOut {
574                        _serde::__private::Some(__field) => __field,
575                        _serde::__private::None => {
576                            #[cfg(feature = "strict")]
577                            return _serde::__private::Err(
578                                <__A::Error as _serde::de::Error>::missing_field(
579                                    "rotationOut",
580                                ),
581                            );
582                            #[cfg(not(feature = "strict"))] Default::default()
583                        }
584                    };
585                    let m_axis = match m_axis {
586                        _serde::__private::Some(__field) => __field,
587                        _serde::__private::None => {
588                            #[cfg(feature = "strict")]
589                            return _serde::__private::Err(
590                                <__A::Error as _serde::de::Error>::missing_field("axis"),
591                            );
592                            #[cfg(not(feature = "strict"))] Default::default()
593                        }
594                    };
595                    let m_angleDegrees = match m_angleDegrees {
596                        _serde::__private::Some(__field) => __field,
597                        _serde::__private::None => {
598                            #[cfg(feature = "strict")]
599                            return _serde::__private::Err(
600                                <__A::Error as _serde::de::Error>::missing_field(
601                                    "angleDegrees",
602                                ),
603                            );
604                            #[cfg(not(feature = "strict"))] Default::default()
605                        }
606                    };
607                    let __ptr = None;
608                    let parent = hkBaseObject { __ptr };
609                    let parent = hkReferencedObject {
610                        __ptr,
611                        parent,
612                        ..Default::default()
613                    };
614                    let parent = hkbBindable {
615                        __ptr,
616                        parent,
617                        m_variableBindingSet,
618                        ..Default::default()
619                    };
620                    let parent = hkbNode {
621                        __ptr,
622                        parent,
623                        m_userData,
624                        m_name,
625                        ..Default::default()
626                    };
627                    let parent = hkbModifier {
628                        __ptr,
629                        parent,
630                        m_enable,
631                        ..Default::default()
632                    };
633                    let __ptr = __A::class_ptr(&mut __map);
634                    _serde::__private::Ok(hkbComputeRotationFromAxisAngleModifier {
635                        __ptr,
636                        parent,
637                        m_rotationOut,
638                        m_axis,
639                        m_angleDegrees,
640                    })
641                }
642            }
643            const FIELDS: &[&str] = &["rotationOut", "axis", "angleDegrees"];
644            _serde::Deserializer::deserialize_struct(
645                deserializer,
646                "hkbComputeRotationFromAxisAngleModifier",
647                FIELDS,
648                __hkbComputeRotationFromAxisAngleModifierVisitor {
649                    marker: _serde::__private::PhantomData::<
650                        hkbComputeRotationFromAxisAngleModifier,
651                    >,
652                    lifetime: _serde::__private::PhantomData,
653                },
654            )
655        }
656    }
657};