havok_classes/generated/
hkRangeInt32Attribute_.rs

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