havok_classes/generated/
hkpStorageSampledHeightFieldShape_.rs

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