havok_classes/generated/
BSDecomposeVectorModifier_.rs

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

havok_classes/generated/
BSDecomposeVectorModifier_.rs
