havok_classes/generated/
BSLookAtModifierBoneData_.rs

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

havok_classes/generated/
BSLookAtModifierBoneData_.rs
