havok_classes/generated/
hkpMultiRayShape_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpMultiRayShape`
5/// - version: `0`
6/// - signature: `0xea2e7ec9`
7/// - size: ` 32`(x86)/` 56`(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 hkpMultiRayShape {
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: hkpShape,
30    /// # C++ Info
31    /// - name: `rays`(ctype: `hkArray<struct hkpMultiRayShapeRay>`)
32    /// - offset: ` 16`(x86)/` 32`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "rays"))]
35    #[cfg_attr(feature = "serde", serde(rename = "rays"))]
36    pub m_rays: Vec<hkpMultiRayShapeRay>,
37    /// # C++ Info
38    /// - name: `rayPenetrationDistance`(ctype: `hkReal`)
39    /// - offset: ` 28`(x86)/` 48`(x86_64)
40    /// - type_size: `  4`(x86)/`  4`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "rayPenetrationDistance"))]
42    #[cfg_attr(feature = "serde", serde(rename = "rayPenetrationDistance"))]
43    pub m_rayPenetrationDistance: f32,
44}
45const _: () = {
46    use havok_serde as _serde;
47    impl _serde::HavokClass for hkpMultiRayShape {
48        #[inline]
49        fn name(&self) -> &'static str {
50            "hkpMultiRayShape"
51        }
52        #[inline]
53        fn signature(&self) -> _serde::__private::Signature {
54            _serde::__private::Signature::new(0xea2e7ec9)
55        }
56        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
57        fn deps_indexes(&self) -> Vec<usize> {
58            let mut v = Vec::new();
59            v.extend(
60                self
61                    .m_rays
62                    .iter()
63                    .flat_map(|class| class.deps_indexes())
64                    .collect::<Vec<usize>>(),
65            );
66            v
67        }
68    }
69    impl _serde::Serialize for hkpMultiRayShape {
70        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
71        where
72            S: _serde::ser::Serializer,
73        {
74            let class_meta = self
75                .__ptr
76                .map(|name| (name, _serde::__private::Signature::new(0xea2e7ec9)));
77            let mut serializer = __serializer
78                .serialize_struct("hkpMultiRayShape", class_meta, (32u64, 56u64))?;
79            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
80            serializer
81                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
82            serializer
83                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
84            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
85            serializer.serialize_field("userData", &self.parent.m_userData)?;
86            serializer.skip_field("type", &self.parent.m_type)?;
87            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
88            serializer
89                .serialize_array_field(
90                    "rays",
91                    &self.m_rays,
92                    TypeSize::Struct {
93                        size_x86: 32u64,
94                        size_x86_64: 32u64,
95                    },
96                )?;
97            serializer
98                .serialize_field(
99                    "rayPenetrationDistance",
100                    &self.m_rayPenetrationDistance,
101                )?;
102            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
103            serializer.end()
104        }
105    }
106};
107#[doc(hidden)]
108#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
109const _: () = {
110    use havok_serde as _serde;
111    #[automatically_derived]
112    impl<'de> _serde::Deserialize<'de> for hkpMultiRayShape {
113        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
114        where
115            __D: _serde::Deserializer<'de>,
116        {
117            #[allow(non_camel_case_types)]
118            enum __Field {
119                m_userData,
120                m_rays,
121                m_rayPenetrationDistance,
122                __ignore,
123            }
124            struct __FieldVisitor;
125            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
126                type Value = __Field;
127                fn expecting(
128                    &self,
129                    __formatter: &mut core::fmt::Formatter,
130                ) -> core::fmt::Result {
131                    core::fmt::Formatter::write_str(__formatter, "field identifier")
132                }
133                /// Intended for use in XML.
134                #[allow(clippy::match_single_binding)]
135                #[allow(clippy::reversed_empty_ranges)]
136                #[allow(clippy::single_match)]
137                fn visit_key<__E>(
138                    self,
139                    __value: &str,
140                ) -> core::result::Result<Self::Value, __E>
141                where
142                    __E: _serde::de::Error,
143                {
144                    match __value {
145                        "userData" => Ok(__Field::m_userData),
146                        "rays" => Ok(__Field::m_rays),
147                        "rayPenetrationDistance" => Ok(__Field::m_rayPenetrationDistance),
148                        _ => Ok(__Field::__ignore),
149                    }
150                }
151            }
152            impl<'de> _serde::Deserialize<'de> for __Field {
153                #[inline]
154                fn deserialize<__D>(
155                    __deserializer: __D,
156                ) -> core::result::Result<Self, __D::Error>
157                where
158                    __D: _serde::Deserializer<'de>,
159                {
160                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
161                }
162            }
163            struct __hkpMultiRayShapeVisitor<'de> {
164                marker: _serde::__private::PhantomData<hkpMultiRayShape>,
165                lifetime: _serde::__private::PhantomData<&'de ()>,
166            }
167            #[allow(clippy::match_single_binding)]
168            #[allow(clippy::reversed_empty_ranges)]
169            #[allow(clippy::single_match)]
170            impl<'de> _serde::de::Visitor<'de> for __hkpMultiRayShapeVisitor<'de> {
171                type Value = hkpMultiRayShape;
172                fn expecting(
173                    &self,
174                    __formatter: &mut core::fmt::Formatter,
175                ) -> core::fmt::Result {
176                    core::fmt::Formatter::write_str(
177                        __formatter,
178                        "struct hkpMultiRayShape",
179                    )
180                }
181                fn visit_struct_for_bytes<__A>(
182                    self,
183                    mut __map: __A,
184                ) -> _serde::__private::Result<Self::Value, __A::Error>
185                where
186                    __A: _serde::de::MapAccess<'de>,
187                {
188                    let __ptr = __A::class_ptr(&mut __map);
189                    let parent = __A::parent_value(&mut __map)?;
190                    let mut m_rays: _serde::__private::Option<
191                        Vec<hkpMultiRayShapeRay>,
192                    > = _serde::__private::None;
193                    let mut m_rayPenetrationDistance: _serde::__private::Option<f32> = _serde::__private::None;
194                    for i in 0..2usize {
195                        match i {
196                            0usize => {
197                                if _serde::__private::Option::is_some(&m_rays) {
198                                    return _serde::__private::Err(
199                                        <__A::Error as _serde::de::Error>::duplicate_field("rays"),
200                                    );
201                                }
202                                m_rays = _serde::__private::Some(
203                                    match __A::next_value::<
204                                        Vec<hkpMultiRayShapeRay>,
205                                    >(&mut __map) {
206                                        _serde::__private::Ok(__val) => __val,
207                                        _serde::__private::Err(__err) => {
208                                            return _serde::__private::Err(__err);
209                                        }
210                                    },
211                                );
212                            }
213                            1usize => {
214                                if _serde::__private::Option::is_some(
215                                    &m_rayPenetrationDistance,
216                                ) {
217                                    return _serde::__private::Err(
218                                        <__A::Error as _serde::de::Error>::duplicate_field(
219                                            "rayPenetrationDistance",
220                                        ),
221                                    );
222                                }
223                                m_rayPenetrationDistance = _serde::__private::Some(
224                                    match __A::next_value::<f32>(&mut __map) {
225                                        _serde::__private::Ok(__val) => __val,
226                                        _serde::__private::Err(__err) => {
227                                            return _serde::__private::Err(__err);
228                                        }
229                                    },
230                                );
231                            }
232                            _ => {}
233                        }
234                    }
235                    __A::pad(&mut __map, 0usize, 4usize)?;
236                    let m_rays = match m_rays {
237                        _serde::__private::Some(__field) => __field,
238                        _serde::__private::None => {
239                            return _serde::__private::Err(
240                                <__A::Error as _serde::de::Error>::missing_field("rays"),
241                            );
242                        }
243                    };
244                    let m_rayPenetrationDistance = match m_rayPenetrationDistance {
245                        _serde::__private::Some(__field) => __field,
246                        _serde::__private::None => {
247                            return _serde::__private::Err(
248                                <__A::Error as _serde::de::Error>::missing_field(
249                                    "rayPenetrationDistance",
250                                ),
251                            );
252                        }
253                    };
254                    _serde::__private::Ok(hkpMultiRayShape {
255                        __ptr,
256                        parent,
257                        m_rays,
258                        m_rayPenetrationDistance,
259                    })
260                }
261                #[allow(clippy::manual_unwrap_or_default)]
262                fn visit_struct<__A>(
263                    self,
264                    mut __map: __A,
265                ) -> _serde::__private::Result<Self::Value, __A::Error>
266                where
267                    __A: _serde::de::MapAccess<'de>,
268                {
269                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
270                    let mut m_rays: _serde::__private::Option<
271                        Vec<hkpMultiRayShapeRay>,
272                    > = _serde::__private::None;
273                    let mut m_rayPenetrationDistance: _serde::__private::Option<f32> = _serde::__private::None;
274                    while let _serde::__private::Some(__key) = {
275                        __A::next_key::<__Field>(&mut __map)?
276                    } {
277                        match __key {
278                            __Field::m_userData => {
279                                #[cfg(
280                                    any(feature = "strict", feature = "ignore_duplicates")
281                                )]
282                                if _serde::__private::Option::is_some(&m_userData) {
283                                    #[cfg(feature = "ignore_duplicates")]
284                                    {
285                                        __A::skip_value(&mut __map)?;
286                                        continue;
287                                    }
288                                    #[cfg(feature = "strict")]
289                                    return _serde::__private::Err(
290                                        <__A::Error as _serde::de::Error>::duplicate_field(
291                                            "userData",
292                                        ),
293                                    );
294                                }
295                                m_userData = _serde::__private::Some(
296                                    match __A::next_value::<Ulong>(&mut __map) {
297                                        _serde::__private::Ok(__val) => __val,
298                                        _serde::__private::Err(__err) => {
299                                            return _serde::__private::Err(__err);
300                                        }
301                                    },
302                                );
303                            }
304                            __Field::m_rays => {
305                                #[cfg(
306                                    any(feature = "strict", feature = "ignore_duplicates")
307                                )]
308                                if _serde::__private::Option::is_some(&m_rays) {
309                                    #[cfg(feature = "ignore_duplicates")]
310                                    {
311                                        __A::skip_value(&mut __map)?;
312                                        continue;
313                                    }
314                                    #[cfg(feature = "strict")]
315                                    return _serde::__private::Err(
316                                        <__A::Error as _serde::de::Error>::duplicate_field("rays"),
317                                    );
318                                }
319                                m_rays = _serde::__private::Some(
320                                    match __A::next_value::<
321                                        Vec<hkpMultiRayShapeRay>,
322                                    >(&mut __map) {
323                                        _serde::__private::Ok(__val) => __val,
324                                        _serde::__private::Err(__err) => {
325                                            return _serde::__private::Err(__err);
326                                        }
327                                    },
328                                );
329                            }
330                            __Field::m_rayPenetrationDistance => {
331                                #[cfg(
332                                    any(feature = "strict", feature = "ignore_duplicates")
333                                )]
334                                if _serde::__private::Option::is_some(
335                                    &m_rayPenetrationDistance,
336                                ) {
337                                    #[cfg(feature = "ignore_duplicates")]
338                                    {
339                                        __A::skip_value(&mut __map)?;
340                                        continue;
341                                    }
342                                    #[cfg(feature = "strict")]
343                                    return _serde::__private::Err(
344                                        <__A::Error as _serde::de::Error>::duplicate_field(
345                                            "rayPenetrationDistance",
346                                        ),
347                                    );
348                                }
349                                m_rayPenetrationDistance = _serde::__private::Some(
350                                    match __A::next_value::<f32>(&mut __map) {
351                                        _serde::__private::Ok(__val) => __val,
352                                        _serde::__private::Err(__err) => {
353                                            return _serde::__private::Err(__err);
354                                        }
355                                    },
356                                );
357                            }
358                            _ => __A::skip_value(&mut __map)?,
359                        }
360                    }
361                    let m_userData = match m_userData {
362                        _serde::__private::Some(__field) => __field,
363                        _serde::__private::None => {
364                            #[cfg(feature = "strict")]
365                            return _serde::__private::Err(
366                                <__A::Error as _serde::de::Error>::missing_field("userData"),
367                            );
368                            #[cfg(not(feature = "strict"))] Default::default()
369                        }
370                    };
371                    let m_rays = match m_rays {
372                        _serde::__private::Some(__field) => __field,
373                        _serde::__private::None => {
374                            #[cfg(feature = "strict")]
375                            return _serde::__private::Err(
376                                <__A::Error as _serde::de::Error>::missing_field("rays"),
377                            );
378                            #[cfg(not(feature = "strict"))] Default::default()
379                        }
380                    };
381                    let m_rayPenetrationDistance = match m_rayPenetrationDistance {
382                        _serde::__private::Some(__field) => __field,
383                        _serde::__private::None => {
384                            #[cfg(feature = "strict")]
385                            return _serde::__private::Err(
386                                <__A::Error as _serde::de::Error>::missing_field(
387                                    "rayPenetrationDistance",
388                                ),
389                            );
390                            #[cfg(not(feature = "strict"))] Default::default()
391                        }
392                    };
393                    let __ptr = None;
394                    let parent = hkBaseObject { __ptr };
395                    let parent = hkReferencedObject {
396                        __ptr,
397                        parent,
398                        ..Default::default()
399                    };
400                    let parent = hkpShape {
401                        __ptr,
402                        parent,
403                        m_userData,
404                        ..Default::default()
405                    };
406                    let __ptr = __A::class_ptr(&mut __map);
407                    _serde::__private::Ok(hkpMultiRayShape {
408                        __ptr,
409                        parent,
410                        m_rays,
411                        m_rayPenetrationDistance,
412                    })
413                }
414            }
415            const FIELDS: &[&str] = &["rays", "rayPenetrationDistance"];
416            _serde::Deserializer::deserialize_struct(
417                deserializer,
418                "hkpMultiRayShape",
419                FIELDS,
420                __hkpMultiRayShapeVisitor {
421                    marker: _serde::__private::PhantomData::<hkpMultiRayShape>,
422                    lifetime: _serde::__private::PhantomData,
423                },
424            )
425        }
426    }
427};