1use super::class_requires::*;
2use super::*;
3#[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 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkpSampledHeightFieldShape,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "storage"))]
35 #[cfg_attr(feature = "serde", serde(rename = "storage"))]
36 pub m_storage: Vec<f32>,
37 #[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 #[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};