havok_classes/generated/
hkxCamera_.rs

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

havok_classes/generated/
hkxCamera_.rs
