havok_classes/generated/
hkbSetWorldFromModelModifier_.rs

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