havok_classes/generated/
hkbComputeDirectionModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbComputeDirectionModifier`
5/// - version: `0`
6/// - signature: `0xdf358bd3`
7/// - size: `112`(x86)/`144`(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 hkbComputeDirectionModifier<'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: `pointIn`(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 = "pointIn"))]
36    #[cfg_attr(feature = "serde", serde(rename = "pointIn"))]
37    pub m_pointIn: Vector4,
38    /// # C++ Info
39    /// - name: `pointOut`(ctype: `hkVector4`)
40    /// - offset: ` 64`(x86)/` 96`(x86_64)
41    /// - type_size: ` 16`(x86)/` 16`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "pointOut"))]
43    #[cfg_attr(feature = "serde", serde(rename = "pointOut"))]
44    pub m_pointOut: Vector4,
45    /// # C++ Info
46    /// - name: `groundAngleOut`(ctype: `hkReal`)
47    /// - offset: ` 80`(x86)/`112`(x86_64)
48    /// - type_size: `  4`(x86)/`  4`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "groundAngleOut"))]
50    #[cfg_attr(feature = "serde", serde(rename = "groundAngleOut"))]
51    pub m_groundAngleOut: f32,
52    /// # C++ Info
53    /// - name: `upAngleOut`(ctype: `hkReal`)
54    /// - offset: ` 84`(x86)/`116`(x86_64)
55    /// - type_size: `  4`(x86)/`  4`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "upAngleOut"))]
57    #[cfg_attr(feature = "serde", serde(rename = "upAngleOut"))]
58    pub m_upAngleOut: f32,
59    /// # C++ Info
60    /// - name: `verticalOffset`(ctype: `hkReal`)
61    /// - offset: ` 88`(x86)/`120`(x86_64)
62    /// - type_size: `  4`(x86)/`  4`(x86_64)
63    #[cfg_attr(feature = "json_schema", schemars(rename = "verticalOffset"))]
64    #[cfg_attr(feature = "serde", serde(rename = "verticalOffset"))]
65    pub m_verticalOffset: f32,
66    /// # C++ Info
67    /// - name: `reverseGroundAngle`(ctype: `hkBool`)
68    /// - offset: ` 92`(x86)/`124`(x86_64)
69    /// - type_size: `  1`(x86)/`  1`(x86_64)
70    #[cfg_attr(feature = "json_schema", schemars(rename = "reverseGroundAngle"))]
71    #[cfg_attr(feature = "serde", serde(rename = "reverseGroundAngle"))]
72    pub m_reverseGroundAngle: bool,
73    /// # C++ Info
74    /// - name: `reverseUpAngle`(ctype: `hkBool`)
75    /// - offset: ` 93`(x86)/`125`(x86_64)
76    /// - type_size: `  1`(x86)/`  1`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "reverseUpAngle"))]
78    #[cfg_attr(feature = "serde", serde(rename = "reverseUpAngle"))]
79    pub m_reverseUpAngle: bool,
80    /// # C++ Info
81    /// - name: `projectPoint`(ctype: `hkBool`)
82    /// - offset: ` 94`(x86)/`126`(x86_64)
83    /// - type_size: `  1`(x86)/`  1`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "projectPoint"))]
85    #[cfg_attr(feature = "serde", serde(rename = "projectPoint"))]
86    pub m_projectPoint: bool,
87    /// # C++ Info
88    /// - name: `normalizePoint`(ctype: `hkBool`)
89    /// - offset: ` 95`(x86)/`127`(x86_64)
90    /// - type_size: `  1`(x86)/`  1`(x86_64)
91    #[cfg_attr(feature = "json_schema", schemars(rename = "normalizePoint"))]
92    #[cfg_attr(feature = "serde", serde(rename = "normalizePoint"))]
93    pub m_normalizePoint: bool,
94    /// # C++ Info
95    /// - name: `computeOnlyOnce`(ctype: `hkBool`)
96    /// - offset: ` 96`(x86)/`128`(x86_64)
97    /// - type_size: `  1`(x86)/`  1`(x86_64)
98    #[cfg_attr(feature = "json_schema", schemars(rename = "computeOnlyOnce"))]
99    #[cfg_attr(feature = "serde", serde(rename = "computeOnlyOnce"))]
100    pub m_computeOnlyOnce: bool,
101    /// # C++ Info
102    /// - name: `computedOutput`(ctype: `hkBool`)
103    /// - offset: ` 97`(x86)/`129`(x86_64)
104    /// - type_size: `  1`(x86)/`  1`(x86_64)
105    #[cfg_attr(feature = "json_schema", schemars(rename = "computedOutput"))]
106    #[cfg_attr(feature = "serde", serde(rename = "computedOutput"))]
107    pub m_computedOutput: bool,
108}
109const _: () = {
110    use havok_serde as _serde;
111    impl<'a> _serde::HavokClass for hkbComputeDirectionModifier<'a> {
112        #[inline]
113        fn name(&self) -> &'static str {
114            "hkbComputeDirectionModifier"
115        }
116        #[inline]
117        fn signature(&self) -> _serde::__private::Signature {
118            _serde::__private::Signature::new(0xdf358bd3)
119        }
120        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
121        fn deps_indexes(&self) -> Vec<usize> {
122            let mut v = Vec::new();
123            v.push(self.parent.parent.parent.m_variableBindingSet.get());
124            v
125        }
126    }
127    impl<'a> _serde::Serialize for hkbComputeDirectionModifier<'a> {
128        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
129        where
130            S: _serde::ser::Serializer,
131        {
132            let class_meta = self
133                .__ptr
134                .map(|name| (name, _serde::__private::Signature::new(0xdf358bd3)));
135            let mut serializer = __serializer
136                .serialize_struct(
137                    "hkbComputeDirectionModifier",
138                    class_meta,
139                    (112u64, 144u64),
140                )?;
141            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
142            serializer
143                .skip_field(
144                    "memSizeAndFlags",
145                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
146                )?;
147            serializer
148                .skip_field(
149                    "referenceCount",
150                    &self.parent.parent.parent.parent.m_referenceCount,
151                )?;
152            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
153            serializer
154                .serialize_field(
155                    "variableBindingSet",
156                    &self.parent.parent.parent.m_variableBindingSet,
157                )?;
158            serializer
159                .skip_array_field(
160                    "cachedBindables",
161                    &self.parent.parent.parent.m_cachedBindables,
162                    TypeSize::NonPtr,
163                )?;
164            serializer
165                .skip_field(
166                    "areBindablesCached",
167                    &self.parent.parent.parent.m_areBindablesCached,
168                )?;
169            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
170            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
171            serializer.serialize_field("name", &self.parent.parent.m_name)?;
172            serializer.skip_field("id", &self.parent.parent.m_id)?;
173            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
174            serializer
175                .skip_fixed_array_field(
176                    "padNode",
177                    self.parent.parent.m_padNode.as_slice(),
178                    TypeSize::NonPtr,
179                )?;
180            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
181            serializer.serialize_field("enable", &self.parent.m_enable)?;
182            serializer
183                .skip_fixed_array_field(
184                    "padModifier",
185                    self.parent.m_padModifier.as_slice(),
186                    TypeSize::NonPtr,
187                )?;
188            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
189            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
190            serializer.serialize_field("pointIn", &self.m_pointIn)?;
191            serializer.serialize_field("pointOut", &self.m_pointOut)?;
192            serializer.serialize_field("groundAngleOut", &self.m_groundAngleOut)?;
193            serializer.serialize_field("upAngleOut", &self.m_upAngleOut)?;
194            serializer.serialize_field("verticalOffset", &self.m_verticalOffset)?;
195            serializer
196                .serialize_field("reverseGroundAngle", &self.m_reverseGroundAngle)?;
197            serializer.serialize_field("reverseUpAngle", &self.m_reverseUpAngle)?;
198            serializer.serialize_field("projectPoint", &self.m_projectPoint)?;
199            serializer.serialize_field("normalizePoint", &self.m_normalizePoint)?;
200            serializer.serialize_field("computeOnlyOnce", &self.m_computeOnlyOnce)?;
201            serializer.serialize_field("computedOutput", &self.m_computedOutput)?;
202            serializer.pad_field([0u8; 14usize].as_slice(), [0u8; 14usize].as_slice())?;
203            serializer.end()
204        }
205    }
206};
207#[doc(hidden)]
208#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
209const _: () = {
210    use havok_serde as _serde;
211    #[automatically_derived]
212    impl<'de> _serde::Deserialize<'de> for hkbComputeDirectionModifier<'de> {
213        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
214        where
215            __D: _serde::Deserializer<'de>,
216        {
217            #[allow(non_camel_case_types)]
218            enum __Field {
219                m_variableBindingSet,
220                m_userData,
221                m_name,
222                m_enable,
223                m_pointIn,
224                m_pointOut,
225                m_groundAngleOut,
226                m_upAngleOut,
227                m_verticalOffset,
228                m_reverseGroundAngle,
229                m_reverseUpAngle,
230                m_projectPoint,
231                m_normalizePoint,
232                m_computeOnlyOnce,
233                m_computedOutput,
234                __ignore,
235            }
236            struct __FieldVisitor;
237            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
238                type Value = __Field;
239                fn expecting(
240                    &self,
241                    __formatter: &mut core::fmt::Formatter,
242                ) -> core::fmt::Result {
243                    core::fmt::Formatter::write_str(__formatter, "field identifier")
244                }
245                /// Intended for use in XML.
246                #[allow(clippy::match_single_binding)]
247                #[allow(clippy::reversed_empty_ranges)]
248                #[allow(clippy::single_match)]
249                fn visit_key<__E>(
250                    self,
251                    __value: &str,
252                ) -> core::result::Result<Self::Value, __E>
253                where
254                    __E: _serde::de::Error,
255                {
256                    match __value {
257                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
258                        "userData" => Ok(__Field::m_userData),
259                        "name" => Ok(__Field::m_name),
260                        "enable" => Ok(__Field::m_enable),
261                        "pointIn" => Ok(__Field::m_pointIn),
262                        "pointOut" => Ok(__Field::m_pointOut),
263                        "groundAngleOut" => Ok(__Field::m_groundAngleOut),
264                        "upAngleOut" => Ok(__Field::m_upAngleOut),
265                        "verticalOffset" => Ok(__Field::m_verticalOffset),
266                        "reverseGroundAngle" => Ok(__Field::m_reverseGroundAngle),
267                        "reverseUpAngle" => Ok(__Field::m_reverseUpAngle),
268                        "projectPoint" => Ok(__Field::m_projectPoint),
269                        "normalizePoint" => Ok(__Field::m_normalizePoint),
270                        "computeOnlyOnce" => Ok(__Field::m_computeOnlyOnce),
271                        "computedOutput" => Ok(__Field::m_computedOutput),
272                        _ => Ok(__Field::__ignore),
273                    }
274                }
275            }
276            impl<'de> _serde::Deserialize<'de> for __Field {
277                #[inline]
278                fn deserialize<__D>(
279                    __deserializer: __D,
280                ) -> core::result::Result<Self, __D::Error>
281                where
282                    __D: _serde::Deserializer<'de>,
283                {
284                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
285                }
286            }
287            struct __hkbComputeDirectionModifierVisitor<'de> {
288                marker: _serde::__private::PhantomData<hkbComputeDirectionModifier<'de>>,
289                lifetime: _serde::__private::PhantomData<&'de ()>,
290            }
291            #[allow(clippy::match_single_binding)]
292            #[allow(clippy::reversed_empty_ranges)]
293            #[allow(clippy::single_match)]
294            impl<'de> _serde::de::Visitor<'de>
295            for __hkbComputeDirectionModifierVisitor<'de> {
296                type Value = hkbComputeDirectionModifier<'de>;
297                fn expecting(
298                    &self,
299                    __formatter: &mut core::fmt::Formatter,
300                ) -> core::fmt::Result {
301                    core::fmt::Formatter::write_str(
302                        __formatter,
303                        "struct hkbComputeDirectionModifier",
304                    )
305                }
306                fn visit_struct_for_bytes<__A>(
307                    self,
308                    mut __map: __A,
309                ) -> _serde::__private::Result<Self::Value, __A::Error>
310                where
311                    __A: _serde::de::MapAccess<'de>,
312                {
313                    let __ptr = __A::class_ptr(&mut __map);
314                    let parent = __A::parent_value(&mut __map)?;
315                    let mut m_pointIn: _serde::__private::Option<Vector4> = _serde::__private::None;
316                    let mut m_pointOut: _serde::__private::Option<Vector4> = _serde::__private::None;
317                    let mut m_groundAngleOut: _serde::__private::Option<f32> = _serde::__private::None;
318                    let mut m_upAngleOut: _serde::__private::Option<f32> = _serde::__private::None;
319                    let mut m_verticalOffset: _serde::__private::Option<f32> = _serde::__private::None;
320                    let mut m_reverseGroundAngle: _serde::__private::Option<bool> = _serde::__private::None;
321                    let mut m_reverseUpAngle: _serde::__private::Option<bool> = _serde::__private::None;
322                    let mut m_projectPoint: _serde::__private::Option<bool> = _serde::__private::None;
323                    let mut m_normalizePoint: _serde::__private::Option<bool> = _serde::__private::None;
324                    let mut m_computeOnlyOnce: _serde::__private::Option<bool> = _serde::__private::None;
325                    let mut m_computedOutput: _serde::__private::Option<bool> = _serde::__private::None;
326                    for i in 0..11usize {
327                        match i {
328                            0usize => {
329                                if _serde::__private::Option::is_some(&m_pointIn) {
330                                    return _serde::__private::Err(
331                                        <__A::Error as _serde::de::Error>::duplicate_field(
332                                            "pointIn",
333                                        ),
334                                    );
335                                }
336                                __A::pad(&mut __map, 4usize, 0usize)?;
337                                m_pointIn = _serde::__private::Some(
338                                    match __A::next_value::<Vector4>(&mut __map) {
339                                        _serde::__private::Ok(__val) => __val,
340                                        _serde::__private::Err(__err) => {
341                                            return _serde::__private::Err(__err);
342                                        }
343                                    },
344                                );
345                            }
346                            1usize => {
347                                if _serde::__private::Option::is_some(&m_pointOut) {
348                                    return _serde::__private::Err(
349                                        <__A::Error as _serde::de::Error>::duplicate_field(
350                                            "pointOut",
351                                        ),
352                                    );
353                                }
354                                m_pointOut = _serde::__private::Some(
355                                    match __A::next_value::<Vector4>(&mut __map) {
356                                        _serde::__private::Ok(__val) => __val,
357                                        _serde::__private::Err(__err) => {
358                                            return _serde::__private::Err(__err);
359                                        }
360                                    },
361                                );
362                            }
363                            2usize => {
364                                if _serde::__private::Option::is_some(&m_groundAngleOut) {
365                                    return _serde::__private::Err(
366                                        <__A::Error as _serde::de::Error>::duplicate_field(
367                                            "groundAngleOut",
368                                        ),
369                                    );
370                                }
371                                m_groundAngleOut = _serde::__private::Some(
372                                    match __A::next_value::<f32>(&mut __map) {
373                                        _serde::__private::Ok(__val) => __val,
374                                        _serde::__private::Err(__err) => {
375                                            return _serde::__private::Err(__err);
376                                        }
377                                    },
378                                );
379                            }
380                            3usize => {
381                                if _serde::__private::Option::is_some(&m_upAngleOut) {
382                                    return _serde::__private::Err(
383                                        <__A::Error as _serde::de::Error>::duplicate_field(
384                                            "upAngleOut",
385                                        ),
386                                    );
387                                }
388                                m_upAngleOut = _serde::__private::Some(
389                                    match __A::next_value::<f32>(&mut __map) {
390                                        _serde::__private::Ok(__val) => __val,
391                                        _serde::__private::Err(__err) => {
392                                            return _serde::__private::Err(__err);
393                                        }
394                                    },
395                                );
396                            }
397                            4usize => {
398                                if _serde::__private::Option::is_some(&m_verticalOffset) {
399                                    return _serde::__private::Err(
400                                        <__A::Error as _serde::de::Error>::duplicate_field(
401                                            "verticalOffset",
402                                        ),
403                                    );
404                                }
405                                m_verticalOffset = _serde::__private::Some(
406                                    match __A::next_value::<f32>(&mut __map) {
407                                        _serde::__private::Ok(__val) => __val,
408                                        _serde::__private::Err(__err) => {
409                                            return _serde::__private::Err(__err);
410                                        }
411                                    },
412                                );
413                            }
414                            5usize => {
415                                if _serde::__private::Option::is_some(
416                                    &m_reverseGroundAngle,
417                                ) {
418                                    return _serde::__private::Err(
419                                        <__A::Error as _serde::de::Error>::duplicate_field(
420                                            "reverseGroundAngle",
421                                        ),
422                                    );
423                                }
424                                m_reverseGroundAngle = _serde::__private::Some(
425                                    match __A::next_value::<bool>(&mut __map) {
426                                        _serde::__private::Ok(__val) => __val,
427                                        _serde::__private::Err(__err) => {
428                                            return _serde::__private::Err(__err);
429                                        }
430                                    },
431                                );
432                            }
433                            6usize => {
434                                if _serde::__private::Option::is_some(&m_reverseUpAngle) {
435                                    return _serde::__private::Err(
436                                        <__A::Error as _serde::de::Error>::duplicate_field(
437                                            "reverseUpAngle",
438                                        ),
439                                    );
440                                }
441                                m_reverseUpAngle = _serde::__private::Some(
442                                    match __A::next_value::<bool>(&mut __map) {
443                                        _serde::__private::Ok(__val) => __val,
444                                        _serde::__private::Err(__err) => {
445                                            return _serde::__private::Err(__err);
446                                        }
447                                    },
448                                );
449                            }
450                            7usize => {
451                                if _serde::__private::Option::is_some(&m_projectPoint) {
452                                    return _serde::__private::Err(
453                                        <__A::Error as _serde::de::Error>::duplicate_field(
454                                            "projectPoint",
455                                        ),
456                                    );
457                                }
458                                m_projectPoint = _serde::__private::Some(
459                                    match __A::next_value::<bool>(&mut __map) {
460                                        _serde::__private::Ok(__val) => __val,
461                                        _serde::__private::Err(__err) => {
462                                            return _serde::__private::Err(__err);
463                                        }
464                                    },
465                                );
466                            }
467                            8usize => {
468                                if _serde::__private::Option::is_some(&m_normalizePoint) {
469                                    return _serde::__private::Err(
470                                        <__A::Error as _serde::de::Error>::duplicate_field(
471                                            "normalizePoint",
472                                        ),
473                                    );
474                                }
475                                m_normalizePoint = _serde::__private::Some(
476                                    match __A::next_value::<bool>(&mut __map) {
477                                        _serde::__private::Ok(__val) => __val,
478                                        _serde::__private::Err(__err) => {
479                                            return _serde::__private::Err(__err);
480                                        }
481                                    },
482                                );
483                            }
484                            9usize => {
485                                if _serde::__private::Option::is_some(&m_computeOnlyOnce) {
486                                    return _serde::__private::Err(
487                                        <__A::Error as _serde::de::Error>::duplicate_field(
488                                            "computeOnlyOnce",
489                                        ),
490                                    );
491                                }
492                                m_computeOnlyOnce = _serde::__private::Some(
493                                    match __A::next_value::<bool>(&mut __map) {
494                                        _serde::__private::Ok(__val) => __val,
495                                        _serde::__private::Err(__err) => {
496                                            return _serde::__private::Err(__err);
497                                        }
498                                    },
499                                );
500                            }
501                            10usize => {
502                                if _serde::__private::Option::is_some(&m_computedOutput) {
503                                    return _serde::__private::Err(
504                                        <__A::Error as _serde::de::Error>::duplicate_field(
505                                            "computedOutput",
506                                        ),
507                                    );
508                                }
509                                m_computedOutput = _serde::__private::Some(
510                                    match __A::next_value::<bool>(&mut __map) {
511                                        _serde::__private::Ok(__val) => __val,
512                                        _serde::__private::Err(__err) => {
513                                            return _serde::__private::Err(__err);
514                                        }
515                                    },
516                                );
517                            }
518                            _ => {}
519                        }
520                    }
521                    __A::pad(&mut __map, 14usize, 14usize)?;
522                    let m_pointIn = match m_pointIn {
523                        _serde::__private::Some(__field) => __field,
524                        _serde::__private::None => {
525                            return _serde::__private::Err(
526                                <__A::Error as _serde::de::Error>::missing_field("pointIn"),
527                            );
528                        }
529                    };
530                    let m_pointOut = match m_pointOut {
531                        _serde::__private::Some(__field) => __field,
532                        _serde::__private::None => {
533                            return _serde::__private::Err(
534                                <__A::Error as _serde::de::Error>::missing_field("pointOut"),
535                            );
536                        }
537                    };
538                    let m_groundAngleOut = match m_groundAngleOut {
539                        _serde::__private::Some(__field) => __field,
540                        _serde::__private::None => {
541                            return _serde::__private::Err(
542                                <__A::Error as _serde::de::Error>::missing_field(
543                                    "groundAngleOut",
544                                ),
545                            );
546                        }
547                    };
548                    let m_upAngleOut = match m_upAngleOut {
549                        _serde::__private::Some(__field) => __field,
550                        _serde::__private::None => {
551                            return _serde::__private::Err(
552                                <__A::Error as _serde::de::Error>::missing_field(
553                                    "upAngleOut",
554                                ),
555                            );
556                        }
557                    };
558                    let m_verticalOffset = match m_verticalOffset {
559                        _serde::__private::Some(__field) => __field,
560                        _serde::__private::None => {
561                            return _serde::__private::Err(
562                                <__A::Error as _serde::de::Error>::missing_field(
563                                    "verticalOffset",
564                                ),
565                            );
566                        }
567                    };
568                    let m_reverseGroundAngle = match m_reverseGroundAngle {
569                        _serde::__private::Some(__field) => __field,
570                        _serde::__private::None => {
571                            return _serde::__private::Err(
572                                <__A::Error as _serde::de::Error>::missing_field(
573                                    "reverseGroundAngle",
574                                ),
575                            );
576                        }
577                    };
578                    let m_reverseUpAngle = match m_reverseUpAngle {
579                        _serde::__private::Some(__field) => __field,
580                        _serde::__private::None => {
581                            return _serde::__private::Err(
582                                <__A::Error as _serde::de::Error>::missing_field(
583                                    "reverseUpAngle",
584                                ),
585                            );
586                        }
587                    };
588                    let m_projectPoint = match m_projectPoint {
589                        _serde::__private::Some(__field) => __field,
590                        _serde::__private::None => {
591                            return _serde::__private::Err(
592                                <__A::Error as _serde::de::Error>::missing_field(
593                                    "projectPoint",
594                                ),
595                            );
596                        }
597                    };
598                    let m_normalizePoint = match m_normalizePoint {
599                        _serde::__private::Some(__field) => __field,
600                        _serde::__private::None => {
601                            return _serde::__private::Err(
602                                <__A::Error as _serde::de::Error>::missing_field(
603                                    "normalizePoint",
604                                ),
605                            );
606                        }
607                    };
608                    let m_computeOnlyOnce = match m_computeOnlyOnce {
609                        _serde::__private::Some(__field) => __field,
610                        _serde::__private::None => {
611                            return _serde::__private::Err(
612                                <__A::Error as _serde::de::Error>::missing_field(
613                                    "computeOnlyOnce",
614                                ),
615                            );
616                        }
617                    };
618                    let m_computedOutput = match m_computedOutput {
619                        _serde::__private::Some(__field) => __field,
620                        _serde::__private::None => {
621                            return _serde::__private::Err(
622                                <__A::Error as _serde::de::Error>::missing_field(
623                                    "computedOutput",
624                                ),
625                            );
626                        }
627                    };
628                    _serde::__private::Ok(hkbComputeDirectionModifier {
629                        __ptr,
630                        parent,
631                        m_pointIn,
632                        m_pointOut,
633                        m_groundAngleOut,
634                        m_upAngleOut,
635                        m_verticalOffset,
636                        m_reverseGroundAngle,
637                        m_reverseUpAngle,
638                        m_projectPoint,
639                        m_normalizePoint,
640                        m_computeOnlyOnce,
641                        m_computedOutput,
642                    })
643                }
644                #[allow(clippy::manual_unwrap_or_default)]
645                fn visit_struct<__A>(
646                    self,
647                    mut __map: __A,
648                ) -> _serde::__private::Result<Self::Value, __A::Error>
649                where
650                    __A: _serde::de::MapAccess<'de>,
651                {
652                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
653                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
654                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
655                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
656                    let mut m_pointIn: _serde::__private::Option<Vector4> = _serde::__private::None;
657                    let mut m_pointOut: _serde::__private::Option<Vector4> = _serde::__private::None;
658                    let mut m_groundAngleOut: _serde::__private::Option<f32> = _serde::__private::None;
659                    let mut m_upAngleOut: _serde::__private::Option<f32> = _serde::__private::None;
660                    let mut m_verticalOffset: _serde::__private::Option<f32> = _serde::__private::None;
661                    let mut m_reverseGroundAngle: _serde::__private::Option<bool> = _serde::__private::None;
662                    let mut m_reverseUpAngle: _serde::__private::Option<bool> = _serde::__private::None;
663                    let mut m_projectPoint: _serde::__private::Option<bool> = _serde::__private::None;
664                    let mut m_normalizePoint: _serde::__private::Option<bool> = _serde::__private::None;
665                    let mut m_computeOnlyOnce: _serde::__private::Option<bool> = _serde::__private::None;
666                    let mut m_computedOutput: _serde::__private::Option<bool> = _serde::__private::None;
667                    while let _serde::__private::Some(__key) = {
668                        __A::next_key::<__Field>(&mut __map)?
669                    } {
670                        match __key {
671                            __Field::m_variableBindingSet => {
672                                #[cfg(
673                                    any(feature = "strict", feature = "ignore_duplicates")
674                                )]
675                                if _serde::__private::Option::is_some(
676                                    &m_variableBindingSet,
677                                ) {
678                                    #[cfg(feature = "ignore_duplicates")]
679                                    {
680                                        __A::skip_value(&mut __map)?;
681                                        continue;
682                                    }
683                                    #[cfg(feature = "strict")]
684                                    return _serde::__private::Err(
685                                        <__A::Error as _serde::de::Error>::duplicate_field(
686                                            "variableBindingSet",
687                                        ),
688                                    );
689                                }
690                                m_variableBindingSet = _serde::__private::Some(
691                                    match __A::next_value::<Pointer>(&mut __map) {
692                                        _serde::__private::Ok(__val) => __val,
693                                        _serde::__private::Err(__err) => {
694                                            return _serde::__private::Err(__err);
695                                        }
696                                    },
697                                );
698                            }
699                            __Field::m_userData => {
700                                #[cfg(
701                                    any(feature = "strict", feature = "ignore_duplicates")
702                                )]
703                                if _serde::__private::Option::is_some(&m_userData) {
704                                    #[cfg(feature = "ignore_duplicates")]
705                                    {
706                                        __A::skip_value(&mut __map)?;
707                                        continue;
708                                    }
709                                    #[cfg(feature = "strict")]
710                                    return _serde::__private::Err(
711                                        <__A::Error as _serde::de::Error>::duplicate_field(
712                                            "userData",
713                                        ),
714                                    );
715                                }
716                                m_userData = _serde::__private::Some(
717                                    match __A::next_value::<Ulong>(&mut __map) {
718                                        _serde::__private::Ok(__val) => __val,
719                                        _serde::__private::Err(__err) => {
720                                            return _serde::__private::Err(__err);
721                                        }
722                                    },
723                                );
724                            }
725                            __Field::m_name => {
726                                #[cfg(
727                                    any(feature = "strict", feature = "ignore_duplicates")
728                                )]
729                                if _serde::__private::Option::is_some(&m_name) {
730                                    #[cfg(feature = "ignore_duplicates")]
731                                    {
732                                        __A::skip_value(&mut __map)?;
733                                        continue;
734                                    }
735                                    #[cfg(feature = "strict")]
736                                    return _serde::__private::Err(
737                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
738                                    );
739                                }
740                                m_name = _serde::__private::Some(
741                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
742                                        _serde::__private::Ok(__val) => __val,
743                                        _serde::__private::Err(__err) => {
744                                            return _serde::__private::Err(__err);
745                                        }
746                                    },
747                                );
748                            }
749                            __Field::m_enable => {
750                                #[cfg(
751                                    any(feature = "strict", feature = "ignore_duplicates")
752                                )]
753                                if _serde::__private::Option::is_some(&m_enable) {
754                                    #[cfg(feature = "ignore_duplicates")]
755                                    {
756                                        __A::skip_value(&mut __map)?;
757                                        continue;
758                                    }
759                                    #[cfg(feature = "strict")]
760                                    return _serde::__private::Err(
761                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
762                                    );
763                                }
764                                m_enable = _serde::__private::Some(
765                                    match __A::next_value::<bool>(&mut __map) {
766                                        _serde::__private::Ok(__val) => __val,
767                                        _serde::__private::Err(__err) => {
768                                            return _serde::__private::Err(__err);
769                                        }
770                                    },
771                                );
772                            }
773                            __Field::m_pointIn => {
774                                #[cfg(
775                                    any(feature = "strict", feature = "ignore_duplicates")
776                                )]
777                                if _serde::__private::Option::is_some(&m_pointIn) {
778                                    #[cfg(feature = "ignore_duplicates")]
779                                    {
780                                        __A::skip_value(&mut __map)?;
781                                        continue;
782                                    }
783                                    #[cfg(feature = "strict")]
784                                    return _serde::__private::Err(
785                                        <__A::Error as _serde::de::Error>::duplicate_field(
786                                            "pointIn",
787                                        ),
788                                    );
789                                }
790                                m_pointIn = _serde::__private::Some(
791                                    match __A::next_value::<Vector4>(&mut __map) {
792                                        _serde::__private::Ok(__val) => __val,
793                                        _serde::__private::Err(__err) => {
794                                            return _serde::__private::Err(__err);
795                                        }
796                                    },
797                                );
798                            }
799                            __Field::m_pointOut => {
800                                #[cfg(
801                                    any(feature = "strict", feature = "ignore_duplicates")
802                                )]
803                                if _serde::__private::Option::is_some(&m_pointOut) {
804                                    #[cfg(feature = "ignore_duplicates")]
805                                    {
806                                        __A::skip_value(&mut __map)?;
807                                        continue;
808                                    }
809                                    #[cfg(feature = "strict")]
810                                    return _serde::__private::Err(
811                                        <__A::Error as _serde::de::Error>::duplicate_field(
812                                            "pointOut",
813                                        ),
814                                    );
815                                }
816                                m_pointOut = _serde::__private::Some(
817                                    match __A::next_value::<Vector4>(&mut __map) {
818                                        _serde::__private::Ok(__val) => __val,
819                                        _serde::__private::Err(__err) => {
820                                            return _serde::__private::Err(__err);
821                                        }
822                                    },
823                                );
824                            }
825                            __Field::m_groundAngleOut => {
826                                #[cfg(
827                                    any(feature = "strict", feature = "ignore_duplicates")
828                                )]
829                                if _serde::__private::Option::is_some(&m_groundAngleOut) {
830                                    #[cfg(feature = "ignore_duplicates")]
831                                    {
832                                        __A::skip_value(&mut __map)?;
833                                        continue;
834                                    }
835                                    #[cfg(feature = "strict")]
836                                    return _serde::__private::Err(
837                                        <__A::Error as _serde::de::Error>::duplicate_field(
838                                            "groundAngleOut",
839                                        ),
840                                    );
841                                }
842                                m_groundAngleOut = _serde::__private::Some(
843                                    match __A::next_value::<f32>(&mut __map) {
844                                        _serde::__private::Ok(__val) => __val,
845                                        _serde::__private::Err(__err) => {
846                                            return _serde::__private::Err(__err);
847                                        }
848                                    },
849                                );
850                            }
851                            __Field::m_upAngleOut => {
852                                #[cfg(
853                                    any(feature = "strict", feature = "ignore_duplicates")
854                                )]
855                                if _serde::__private::Option::is_some(&m_upAngleOut) {
856                                    #[cfg(feature = "ignore_duplicates")]
857                                    {
858                                        __A::skip_value(&mut __map)?;
859                                        continue;
860                                    }
861                                    #[cfg(feature = "strict")]
862                                    return _serde::__private::Err(
863                                        <__A::Error as _serde::de::Error>::duplicate_field(
864                                            "upAngleOut",
865                                        ),
866                                    );
867                                }
868                                m_upAngleOut = _serde::__private::Some(
869                                    match __A::next_value::<f32>(&mut __map) {
870                                        _serde::__private::Ok(__val) => __val,
871                                        _serde::__private::Err(__err) => {
872                                            return _serde::__private::Err(__err);
873                                        }
874                                    },
875                                );
876                            }
877                            __Field::m_verticalOffset => {
878                                #[cfg(
879                                    any(feature = "strict", feature = "ignore_duplicates")
880                                )]
881                                if _serde::__private::Option::is_some(&m_verticalOffset) {
882                                    #[cfg(feature = "ignore_duplicates")]
883                                    {
884                                        __A::skip_value(&mut __map)?;
885                                        continue;
886                                    }
887                                    #[cfg(feature = "strict")]
888                                    return _serde::__private::Err(
889                                        <__A::Error as _serde::de::Error>::duplicate_field(
890                                            "verticalOffset",
891                                        ),
892                                    );
893                                }
894                                m_verticalOffset = _serde::__private::Some(
895                                    match __A::next_value::<f32>(&mut __map) {
896                                        _serde::__private::Ok(__val) => __val,
897                                        _serde::__private::Err(__err) => {
898                                            return _serde::__private::Err(__err);
899                                        }
900                                    },
901                                );
902                            }
903                            __Field::m_reverseGroundAngle => {
904                                #[cfg(
905                                    any(feature = "strict", feature = "ignore_duplicates")
906                                )]
907                                if _serde::__private::Option::is_some(
908                                    &m_reverseGroundAngle,
909                                ) {
910                                    #[cfg(feature = "ignore_duplicates")]
911                                    {
912                                        __A::skip_value(&mut __map)?;
913                                        continue;
914                                    }
915                                    #[cfg(feature = "strict")]
916                                    return _serde::__private::Err(
917                                        <__A::Error as _serde::de::Error>::duplicate_field(
918                                            "reverseGroundAngle",
919                                        ),
920                                    );
921                                }
922                                m_reverseGroundAngle = _serde::__private::Some(
923                                    match __A::next_value::<bool>(&mut __map) {
924                                        _serde::__private::Ok(__val) => __val,
925                                        _serde::__private::Err(__err) => {
926                                            return _serde::__private::Err(__err);
927                                        }
928                                    },
929                                );
930                            }
931                            __Field::m_reverseUpAngle => {
932                                #[cfg(
933                                    any(feature = "strict", feature = "ignore_duplicates")
934                                )]
935                                if _serde::__private::Option::is_some(&m_reverseUpAngle) {
936                                    #[cfg(feature = "ignore_duplicates")]
937                                    {
938                                        __A::skip_value(&mut __map)?;
939                                        continue;
940                                    }
941                                    #[cfg(feature = "strict")]
942                                    return _serde::__private::Err(
943                                        <__A::Error as _serde::de::Error>::duplicate_field(
944                                            "reverseUpAngle",
945                                        ),
946                                    );
947                                }
948                                m_reverseUpAngle = _serde::__private::Some(
949                                    match __A::next_value::<bool>(&mut __map) {
950                                        _serde::__private::Ok(__val) => __val,
951                                        _serde::__private::Err(__err) => {
952                                            return _serde::__private::Err(__err);
953                                        }
954                                    },
955                                );
956                            }
957                            __Field::m_projectPoint => {
958                                #[cfg(
959                                    any(feature = "strict", feature = "ignore_duplicates")
960                                )]
961                                if _serde::__private::Option::is_some(&m_projectPoint) {
962                                    #[cfg(feature = "ignore_duplicates")]
963                                    {
964                                        __A::skip_value(&mut __map)?;
965                                        continue;
966                                    }
967                                    #[cfg(feature = "strict")]
968                                    return _serde::__private::Err(
969                                        <__A::Error as _serde::de::Error>::duplicate_field(
970                                            "projectPoint",
971                                        ),
972                                    );
973                                }
974                                m_projectPoint = _serde::__private::Some(
975                                    match __A::next_value::<bool>(&mut __map) {
976                                        _serde::__private::Ok(__val) => __val,
977                                        _serde::__private::Err(__err) => {
978                                            return _serde::__private::Err(__err);
979                                        }
980                                    },
981                                );
982                            }
983                            __Field::m_normalizePoint => {
984                                #[cfg(
985                                    any(feature = "strict", feature = "ignore_duplicates")
986                                )]
987                                if _serde::__private::Option::is_some(&m_normalizePoint) {
988                                    #[cfg(feature = "ignore_duplicates")]
989                                    {
990                                        __A::skip_value(&mut __map)?;
991                                        continue;
992                                    }
993                                    #[cfg(feature = "strict")]
994                                    return _serde::__private::Err(
995                                        <__A::Error as _serde::de::Error>::duplicate_field(
996                                            "normalizePoint",
997                                        ),
998                                    );
999                                }
1000                                m_normalizePoint = _serde::__private::Some(
1001                                    match __A::next_value::<bool>(&mut __map) {
1002                                        _serde::__private::Ok(__val) => __val,
1003                                        _serde::__private::Err(__err) => {
1004                                            return _serde::__private::Err(__err);
1005                                        }
1006                                    },
1007                                );
1008                            }
1009                            __Field::m_computeOnlyOnce => {
1010                                #[cfg(
1011                                    any(feature = "strict", feature = "ignore_duplicates")
1012                                )]
1013                                if _serde::__private::Option::is_some(&m_computeOnlyOnce) {
1014                                    #[cfg(feature = "ignore_duplicates")]
1015                                    {
1016                                        __A::skip_value(&mut __map)?;
1017                                        continue;
1018                                    }
1019                                    #[cfg(feature = "strict")]
1020                                    return _serde::__private::Err(
1021                                        <__A::Error as _serde::de::Error>::duplicate_field(
1022                                            "computeOnlyOnce",
1023                                        ),
1024                                    );
1025                                }
1026                                m_computeOnlyOnce = _serde::__private::Some(
1027                                    match __A::next_value::<bool>(&mut __map) {
1028                                        _serde::__private::Ok(__val) => __val,
1029                                        _serde::__private::Err(__err) => {
1030                                            return _serde::__private::Err(__err);
1031                                        }
1032                                    },
1033                                );
1034                            }
1035                            __Field::m_computedOutput => {
1036                                #[cfg(
1037                                    any(feature = "strict", feature = "ignore_duplicates")
1038                                )]
1039                                if _serde::__private::Option::is_some(&m_computedOutput) {
1040                                    #[cfg(feature = "ignore_duplicates")]
1041                                    {
1042                                        __A::skip_value(&mut __map)?;
1043                                        continue;
1044                                    }
1045                                    #[cfg(feature = "strict")]
1046                                    return _serde::__private::Err(
1047                                        <__A::Error as _serde::de::Error>::duplicate_field(
1048                                            "computedOutput",
1049                                        ),
1050                                    );
1051                                }
1052                                m_computedOutput = _serde::__private::Some(
1053                                    match __A::next_value::<bool>(&mut __map) {
1054                                        _serde::__private::Ok(__val) => __val,
1055                                        _serde::__private::Err(__err) => {
1056                                            return _serde::__private::Err(__err);
1057                                        }
1058                                    },
1059                                );
1060                            }
1061                            _ => __A::skip_value(&mut __map)?,
1062                        }
1063                    }
1064                    let m_variableBindingSet = match m_variableBindingSet {
1065                        _serde::__private::Some(__field) => __field,
1066                        _serde::__private::None => {
1067                            #[cfg(feature = "strict")]
1068                            return _serde::__private::Err(
1069                                <__A::Error as _serde::de::Error>::missing_field(
1070                                    "variableBindingSet",
1071                                ),
1072                            );
1073                            #[cfg(not(feature = "strict"))] Default::default()
1074                        }
1075                    };
1076                    let m_userData = match m_userData {
1077                        _serde::__private::Some(__field) => __field,
1078                        _serde::__private::None => {
1079                            #[cfg(feature = "strict")]
1080                            return _serde::__private::Err(
1081                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1082                            );
1083                            #[cfg(not(feature = "strict"))] Default::default()
1084                        }
1085                    };
1086                    let m_name = match m_name {
1087                        _serde::__private::Some(__field) => __field,
1088                        _serde::__private::None => {
1089                            #[cfg(feature = "strict")]
1090                            return _serde::__private::Err(
1091                                <__A::Error as _serde::de::Error>::missing_field("name"),
1092                            );
1093                            #[cfg(not(feature = "strict"))] Default::default()
1094                        }
1095                    };
1096                    let m_enable = match m_enable {
1097                        _serde::__private::Some(__field) => __field,
1098                        _serde::__private::None => {
1099                            #[cfg(feature = "strict")]
1100                            return _serde::__private::Err(
1101                                <__A::Error as _serde::de::Error>::missing_field("enable"),
1102                            );
1103                            #[cfg(not(feature = "strict"))] Default::default()
1104                        }
1105                    };
1106                    let m_pointIn = match m_pointIn {
1107                        _serde::__private::Some(__field) => __field,
1108                        _serde::__private::None => {
1109                            #[cfg(feature = "strict")]
1110                            return _serde::__private::Err(
1111                                <__A::Error as _serde::de::Error>::missing_field("pointIn"),
1112                            );
1113                            #[cfg(not(feature = "strict"))] Default::default()
1114                        }
1115                    };
1116                    let m_pointOut = match m_pointOut {
1117                        _serde::__private::Some(__field) => __field,
1118                        _serde::__private::None => {
1119                            #[cfg(feature = "strict")]
1120                            return _serde::__private::Err(
1121                                <__A::Error as _serde::de::Error>::missing_field("pointOut"),
1122                            );
1123                            #[cfg(not(feature = "strict"))] Default::default()
1124                        }
1125                    };
1126                    let m_groundAngleOut = match m_groundAngleOut {
1127                        _serde::__private::Some(__field) => __field,
1128                        _serde::__private::None => {
1129                            #[cfg(feature = "strict")]
1130                            return _serde::__private::Err(
1131                                <__A::Error as _serde::de::Error>::missing_field(
1132                                    "groundAngleOut",
1133                                ),
1134                            );
1135                            #[cfg(not(feature = "strict"))] Default::default()
1136                        }
1137                    };
1138                    let m_upAngleOut = match m_upAngleOut {
1139                        _serde::__private::Some(__field) => __field,
1140                        _serde::__private::None => {
1141                            #[cfg(feature = "strict")]
1142                            return _serde::__private::Err(
1143                                <__A::Error as _serde::de::Error>::missing_field(
1144                                    "upAngleOut",
1145                                ),
1146                            );
1147                            #[cfg(not(feature = "strict"))] Default::default()
1148                        }
1149                    };
1150                    let m_verticalOffset = match m_verticalOffset {
1151                        _serde::__private::Some(__field) => __field,
1152                        _serde::__private::None => {
1153                            #[cfg(feature = "strict")]
1154                            return _serde::__private::Err(
1155                                <__A::Error as _serde::de::Error>::missing_field(
1156                                    "verticalOffset",
1157                                ),
1158                            );
1159                            #[cfg(not(feature = "strict"))] Default::default()
1160                        }
1161                    };
1162                    let m_reverseGroundAngle = match m_reverseGroundAngle {
1163                        _serde::__private::Some(__field) => __field,
1164                        _serde::__private::None => {
1165                            #[cfg(feature = "strict")]
1166                            return _serde::__private::Err(
1167                                <__A::Error as _serde::de::Error>::missing_field(
1168                                    "reverseGroundAngle",
1169                                ),
1170                            );
1171                            #[cfg(not(feature = "strict"))] Default::default()
1172                        }
1173                    };
1174                    let m_reverseUpAngle = match m_reverseUpAngle {
1175                        _serde::__private::Some(__field) => __field,
1176                        _serde::__private::None => {
1177                            #[cfg(feature = "strict")]
1178                            return _serde::__private::Err(
1179                                <__A::Error as _serde::de::Error>::missing_field(
1180                                    "reverseUpAngle",
1181                                ),
1182                            );
1183                            #[cfg(not(feature = "strict"))] Default::default()
1184                        }
1185                    };
1186                    let m_projectPoint = match m_projectPoint {
1187                        _serde::__private::Some(__field) => __field,
1188                        _serde::__private::None => {
1189                            #[cfg(feature = "strict")]
1190                            return _serde::__private::Err(
1191                                <__A::Error as _serde::de::Error>::missing_field(
1192                                    "projectPoint",
1193                                ),
1194                            );
1195                            #[cfg(not(feature = "strict"))] Default::default()
1196                        }
1197                    };
1198                    let m_normalizePoint = match m_normalizePoint {
1199                        _serde::__private::Some(__field) => __field,
1200                        _serde::__private::None => {
1201                            #[cfg(feature = "strict")]
1202                            return _serde::__private::Err(
1203                                <__A::Error as _serde::de::Error>::missing_field(
1204                                    "normalizePoint",
1205                                ),
1206                            );
1207                            #[cfg(not(feature = "strict"))] Default::default()
1208                        }
1209                    };
1210                    let m_computeOnlyOnce = match m_computeOnlyOnce {
1211                        _serde::__private::Some(__field) => __field,
1212                        _serde::__private::None => {
1213                            #[cfg(feature = "strict")]
1214                            return _serde::__private::Err(
1215                                <__A::Error as _serde::de::Error>::missing_field(
1216                                    "computeOnlyOnce",
1217                                ),
1218                            );
1219                            #[cfg(not(feature = "strict"))] Default::default()
1220                        }
1221                    };
1222                    let m_computedOutput = match m_computedOutput {
1223                        _serde::__private::Some(__field) => __field,
1224                        _serde::__private::None => {
1225                            #[cfg(feature = "strict")]
1226                            return _serde::__private::Err(
1227                                <__A::Error as _serde::de::Error>::missing_field(
1228                                    "computedOutput",
1229                                ),
1230                            );
1231                            #[cfg(not(feature = "strict"))] Default::default()
1232                        }
1233                    };
1234                    let __ptr = None;
1235                    let parent = hkBaseObject { __ptr };
1236                    let parent = hkReferencedObject {
1237                        __ptr,
1238                        parent,
1239                        ..Default::default()
1240                    };
1241                    let parent = hkbBindable {
1242                        __ptr,
1243                        parent,
1244                        m_variableBindingSet,
1245                        ..Default::default()
1246                    };
1247                    let parent = hkbNode {
1248                        __ptr,
1249                        parent,
1250                        m_userData,
1251                        m_name,
1252                        ..Default::default()
1253                    };
1254                    let parent = hkbModifier {
1255                        __ptr,
1256                        parent,
1257                        m_enable,
1258                        ..Default::default()
1259                    };
1260                    let __ptr = __A::class_ptr(&mut __map);
1261                    _serde::__private::Ok(hkbComputeDirectionModifier {
1262                        __ptr,
1263                        parent,
1264                        m_pointIn,
1265                        m_pointOut,
1266                        m_groundAngleOut,
1267                        m_upAngleOut,
1268                        m_verticalOffset,
1269                        m_reverseGroundAngle,
1270                        m_reverseUpAngle,
1271                        m_projectPoint,
1272                        m_normalizePoint,
1273                        m_computeOnlyOnce,
1274                        m_computedOutput,
1275                    })
1276                }
1277            }
1278            const FIELDS: &[&str] = &[
1279                "pointIn",
1280                "pointOut",
1281                "groundAngleOut",
1282                "upAngleOut",
1283                "verticalOffset",
1284                "reverseGroundAngle",
1285                "reverseUpAngle",
1286                "projectPoint",
1287                "normalizePoint",
1288                "computeOnlyOnce",
1289                "computedOutput",
1290            ];
1291            _serde::Deserializer::deserialize_struct(
1292                deserializer,
1293                "hkbComputeDirectionModifier",
1294                FIELDS,
1295                __hkbComputeDirectionModifierVisitor {
1296                    marker: _serde::__private::PhantomData::<
1297                        hkbComputeDirectionModifier,
1298                    >,
1299                    lifetime: _serde::__private::PhantomData,
1300                },
1301            )
1302        }
1303    }
1304};