havok_classes/generated/
hkpSampledHeightFieldShape_.rs

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