havok_classes/generated/
hkpTriSampledHeightFieldCollection_.rs

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