havok_classes/generated/
hkpTriggerVolumeEventInfo_.rs

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

havok_classes/generated/
hkpTriggerVolumeEventInfo_.rs
