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 hkpCompressedSampledHeightFieldShape {
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<u16>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "triangleFlip"))]
42 #[cfg_attr(feature = "serde", serde(rename = "triangleFlip"))]
43 pub m_triangleFlip: bool,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "offset"))]
49 #[cfg_attr(feature = "serde", serde(rename = "offset"))]
50 pub m_offset: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "scale"))]
56 #[cfg_attr(feature = "serde", serde(rename = "scale"))]
57 pub m_scale: f32,
58}
59const _: () = {
60 use havok_serde as _serde;
61 impl _serde::HavokClass for hkpCompressedSampledHeightFieldShape {
62 #[inline]
63 fn name(&self) -> &'static str {
64 "hkpCompressedSampledHeightFieldShape"
65 }
66 #[inline]
67 fn signature(&self) -> _serde::__private::Signature {
68 _serde::__private::Signature::new(0x97b6e143)
69 }
70 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
71 fn deps_indexes(&self) -> Vec<usize> {
72 let mut v = Vec::new();
73 v
74 }
75 }
76 impl _serde::Serialize for hkpCompressedSampledHeightFieldShape {
77 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
78 where
79 S: _serde::ser::Serializer,
80 {
81 let class_meta = self
82 .__ptr
83 .map(|name| (name, _serde::__private::Signature::new(0x97b6e143)));
84 let mut serializer = __serializer
85 .serialize_struct(
86 "hkpCompressedSampledHeightFieldShape",
87 class_meta,
88 (128u64, 144u64),
89 )?;
90 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
91 serializer
92 .skip_field(
93 "memSizeAndFlags",
94 &self.parent.parent.parent.parent.m_memSizeAndFlags,
95 )?;
96 serializer
97 .skip_field(
98 "referenceCount",
99 &self.parent.parent.parent.parent.m_referenceCount,
100 )?;
101 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
102 serializer
103 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
104 serializer.skip_field("type", &self.parent.parent.parent.m_type)?;
105 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
106 serializer.serialize_field("xRes", &self.parent.m_xRes)?;
107 serializer.serialize_field("zRes", &self.parent.m_zRes)?;
108 serializer.serialize_field("heightCenter", &self.parent.m_heightCenter)?;
109 serializer
110 .serialize_field(
111 "useProjectionBasedHeight",
112 &self.parent.m_useProjectionBasedHeight,
113 )?;
114 serializer
115 .serialize_field("heightfieldType", &self.parent.m_heightfieldType)?;
116 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
117 serializer
118 .serialize_field("intToFloatScale", &self.parent.m_intToFloatScale)?;
119 serializer
120 .serialize_field("floatToIntScale", &self.parent.m_floatToIntScale)?;
121 serializer
122 .serialize_field(
123 "floatToIntOffsetFloorCorrected",
124 &self.parent.m_floatToIntOffsetFloorCorrected,
125 )?;
126 serializer.serialize_field("extents", &self.parent.m_extents)?;
127 serializer
128 .serialize_array_field("storage", &self.m_storage, TypeSize::NonPtr)?;
129 serializer.serialize_field("triangleFlip", &self.m_triangleFlip)?;
130 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
131 serializer.serialize_field("offset", &self.m_offset)?;
132 serializer.serialize_field("scale", &self.m_scale)?;
133 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 4usize].as_slice())?;
134 serializer.end()
135 }
136 }
137};
138#[doc(hidden)]
139#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
140const _: () = {
141 use havok_serde as _serde;
142 #[automatically_derived]
143 impl<'de> _serde::Deserialize<'de> for hkpCompressedSampledHeightFieldShape {
144 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
145 where
146 __D: _serde::Deserializer<'de>,
147 {
148 #[allow(non_camel_case_types)]
149 enum __Field {
150 m_userData,
151 m_xRes,
152 m_zRes,
153 m_heightCenter,
154 m_useProjectionBasedHeight,
155 m_heightfieldType,
156 m_intToFloatScale,
157 m_floatToIntScale,
158 m_floatToIntOffsetFloorCorrected,
159 m_extents,
160 m_storage,
161 m_triangleFlip,
162 m_offset,
163 m_scale,
164 __ignore,
165 }
166 struct __FieldVisitor;
167 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
168 type Value = __Field;
169 fn expecting(
170 &self,
171 __formatter: &mut core::fmt::Formatter,
172 ) -> core::fmt::Result {
173 core::fmt::Formatter::write_str(__formatter, "field identifier")
174 }
175 #[allow(clippy::match_single_binding)]
177 #[allow(clippy::reversed_empty_ranges)]
178 #[allow(clippy::single_match)]
179 fn visit_key<__E>(
180 self,
181 __value: &str,
182 ) -> core::result::Result<Self::Value, __E>
183 where
184 __E: _serde::de::Error,
185 {
186 match __value {
187 "userData" => Ok(__Field::m_userData),
188 "xRes" => Ok(__Field::m_xRes),
189 "zRes" => Ok(__Field::m_zRes),
190 "heightCenter" => Ok(__Field::m_heightCenter),
191 "useProjectionBasedHeight" => {
192 Ok(__Field::m_useProjectionBasedHeight)
193 }
194 "heightfieldType" => Ok(__Field::m_heightfieldType),
195 "intToFloatScale" => Ok(__Field::m_intToFloatScale),
196 "floatToIntScale" => Ok(__Field::m_floatToIntScale),
197 "floatToIntOffsetFloorCorrected" => {
198 Ok(__Field::m_floatToIntOffsetFloorCorrected)
199 }
200 "extents" => Ok(__Field::m_extents),
201 "storage" => Ok(__Field::m_storage),
202 "triangleFlip" => Ok(__Field::m_triangleFlip),
203 "offset" => Ok(__Field::m_offset),
204 "scale" => Ok(__Field::m_scale),
205 _ => Ok(__Field::__ignore),
206 }
207 }
208 }
209 impl<'de> _serde::Deserialize<'de> for __Field {
210 #[inline]
211 fn deserialize<__D>(
212 __deserializer: __D,
213 ) -> core::result::Result<Self, __D::Error>
214 where
215 __D: _serde::Deserializer<'de>,
216 {
217 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
218 }
219 }
220 struct __hkpCompressedSampledHeightFieldShapeVisitor<'de> {
221 marker: _serde::__private::PhantomData<
222 hkpCompressedSampledHeightFieldShape,
223 >,
224 lifetime: _serde::__private::PhantomData<&'de ()>,
225 }
226 #[allow(clippy::match_single_binding)]
227 #[allow(clippy::reversed_empty_ranges)]
228 #[allow(clippy::single_match)]
229 impl<'de> _serde::de::Visitor<'de>
230 for __hkpCompressedSampledHeightFieldShapeVisitor<'de> {
231 type Value = hkpCompressedSampledHeightFieldShape;
232 fn expecting(
233 &self,
234 __formatter: &mut core::fmt::Formatter,
235 ) -> core::fmt::Result {
236 core::fmt::Formatter::write_str(
237 __formatter,
238 "struct hkpCompressedSampledHeightFieldShape",
239 )
240 }
241 fn visit_struct_for_bytes<__A>(
242 self,
243 mut __map: __A,
244 ) -> _serde::__private::Result<Self::Value, __A::Error>
245 where
246 __A: _serde::de::MapAccess<'de>,
247 {
248 let __ptr = __A::class_ptr(&mut __map);
249 let parent = __A::parent_value(&mut __map)?;
250 let mut m_storage: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
251 let mut m_triangleFlip: _serde::__private::Option<bool> = _serde::__private::None;
252 let mut m_offset: _serde::__private::Option<f32> = _serde::__private::None;
253 let mut m_scale: _serde::__private::Option<f32> = _serde::__private::None;
254 for i in 0..4usize {
255 match i {
256 0usize => {
257 if _serde::__private::Option::is_some(&m_storage) {
258 return _serde::__private::Err(
259 <__A::Error as _serde::de::Error>::duplicate_field(
260 "storage",
261 ),
262 );
263 }
264 m_storage = _serde::__private::Some(
265 match __A::next_value::<Vec<u16>>(&mut __map) {
266 _serde::__private::Ok(__val) => __val,
267 _serde::__private::Err(__err) => {
268 return _serde::__private::Err(__err);
269 }
270 },
271 );
272 }
273 1usize => {
274 if _serde::__private::Option::is_some(&m_triangleFlip) {
275 return _serde::__private::Err(
276 <__A::Error as _serde::de::Error>::duplicate_field(
277 "triangleFlip",
278 ),
279 );
280 }
281 m_triangleFlip = _serde::__private::Some(
282 match __A::next_value::<bool>(&mut __map) {
283 _serde::__private::Ok(__val) => __val,
284 _serde::__private::Err(__err) => {
285 return _serde::__private::Err(__err);
286 }
287 },
288 );
289 }
290 2usize => {
291 if _serde::__private::Option::is_some(&m_offset) {
292 return _serde::__private::Err(
293 <__A::Error as _serde::de::Error>::duplicate_field("offset"),
294 );
295 }
296 __A::pad(&mut __map, 3usize, 3usize)?;
297 m_offset = _serde::__private::Some(
298 match __A::next_value::<f32>(&mut __map) {
299 _serde::__private::Ok(__val) => __val,
300 _serde::__private::Err(__err) => {
301 return _serde::__private::Err(__err);
302 }
303 },
304 );
305 }
306 3usize => {
307 if _serde::__private::Option::is_some(&m_scale) {
308 return _serde::__private::Err(
309 <__A::Error as _serde::de::Error>::duplicate_field("scale"),
310 );
311 }
312 m_scale = _serde::__private::Some(
313 match __A::next_value::<f32>(&mut __map) {
314 _serde::__private::Ok(__val) => __val,
315 _serde::__private::Err(__err) => {
316 return _serde::__private::Err(__err);
317 }
318 },
319 );
320 }
321 _ => {}
322 }
323 }
324 __A::pad(&mut __map, 8usize, 4usize)?;
325 let m_storage = match m_storage {
326 _serde::__private::Some(__field) => __field,
327 _serde::__private::None => {
328 return _serde::__private::Err(
329 <__A::Error as _serde::de::Error>::missing_field("storage"),
330 );
331 }
332 };
333 let m_triangleFlip = match m_triangleFlip {
334 _serde::__private::Some(__field) => __field,
335 _serde::__private::None => {
336 return _serde::__private::Err(
337 <__A::Error as _serde::de::Error>::missing_field(
338 "triangleFlip",
339 ),
340 );
341 }
342 };
343 let m_offset = match m_offset {
344 _serde::__private::Some(__field) => __field,
345 _serde::__private::None => {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::missing_field("offset"),
348 );
349 }
350 };
351 let m_scale = match m_scale {
352 _serde::__private::Some(__field) => __field,
353 _serde::__private::None => {
354 return _serde::__private::Err(
355 <__A::Error as _serde::de::Error>::missing_field("scale"),
356 );
357 }
358 };
359 _serde::__private::Ok(hkpCompressedSampledHeightFieldShape {
360 __ptr,
361 parent,
362 m_storage,
363 m_triangleFlip,
364 m_offset,
365 m_scale,
366 })
367 }
368 #[allow(clippy::manual_unwrap_or_default)]
369 fn visit_struct<__A>(
370 self,
371 mut __map: __A,
372 ) -> _serde::__private::Result<Self::Value, __A::Error>
373 where
374 __A: _serde::de::MapAccess<'de>,
375 {
376 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
377 let mut m_xRes: _serde::__private::Option<i32> = _serde::__private::None;
378 let mut m_zRes: _serde::__private::Option<i32> = _serde::__private::None;
379 let mut m_heightCenter: _serde::__private::Option<f32> = _serde::__private::None;
380 let mut m_useProjectionBasedHeight: _serde::__private::Option<
381 bool,
382 > = _serde::__private::None;
383 let mut m_heightfieldType: _serde::__private::Option<
384 HeightFieldType,
385 > = _serde::__private::None;
386 let mut m_intToFloatScale: _serde::__private::Option<Vector4> = _serde::__private::None;
387 let mut m_floatToIntScale: _serde::__private::Option<Vector4> = _serde::__private::None;
388 let mut m_floatToIntOffsetFloorCorrected: _serde::__private::Option<
389 Vector4,
390 > = _serde::__private::None;
391 let mut m_extents: _serde::__private::Option<Vector4> = _serde::__private::None;
392 let mut m_storage: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
393 let mut m_triangleFlip: _serde::__private::Option<bool> = _serde::__private::None;
394 let mut m_offset: _serde::__private::Option<f32> = _serde::__private::None;
395 let mut m_scale: _serde::__private::Option<f32> = _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_xRes => {
427 #[cfg(
428 any(feature = "strict", feature = "ignore_duplicates")
429 )]
430 if _serde::__private::Option::is_some(&m_xRes) {
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("xRes"),
439 );
440 }
441 m_xRes = _serde::__private::Some(
442 match __A::next_value::<i32>(&mut __map) {
443 _serde::__private::Ok(__val) => __val,
444 _serde::__private::Err(__err) => {
445 return _serde::__private::Err(__err);
446 }
447 },
448 );
449 }
450 __Field::m_zRes => {
451 #[cfg(
452 any(feature = "strict", feature = "ignore_duplicates")
453 )]
454 if _serde::__private::Option::is_some(&m_zRes) {
455 #[cfg(feature = "ignore_duplicates")]
456 {
457 __A::skip_value(&mut __map)?;
458 continue;
459 }
460 #[cfg(feature = "strict")]
461 return _serde::__private::Err(
462 <__A::Error as _serde::de::Error>::duplicate_field("zRes"),
463 );
464 }
465 m_zRes = _serde::__private::Some(
466 match __A::next_value::<i32>(&mut __map) {
467 _serde::__private::Ok(__val) => __val,
468 _serde::__private::Err(__err) => {
469 return _serde::__private::Err(__err);
470 }
471 },
472 );
473 }
474 __Field::m_heightCenter => {
475 #[cfg(
476 any(feature = "strict", feature = "ignore_duplicates")
477 )]
478 if _serde::__private::Option::is_some(&m_heightCenter) {
479 #[cfg(feature = "ignore_duplicates")]
480 {
481 __A::skip_value(&mut __map)?;
482 continue;
483 }
484 #[cfg(feature = "strict")]
485 return _serde::__private::Err(
486 <__A::Error as _serde::de::Error>::duplicate_field(
487 "heightCenter",
488 ),
489 );
490 }
491 m_heightCenter = _serde::__private::Some(
492 match __A::next_value::<f32>(&mut __map) {
493 _serde::__private::Ok(__val) => __val,
494 _serde::__private::Err(__err) => {
495 return _serde::__private::Err(__err);
496 }
497 },
498 );
499 }
500 __Field::m_useProjectionBasedHeight => {
501 #[cfg(
502 any(feature = "strict", feature = "ignore_duplicates")
503 )]
504 if _serde::__private::Option::is_some(
505 &m_useProjectionBasedHeight,
506 ) {
507 #[cfg(feature = "ignore_duplicates")]
508 {
509 __A::skip_value(&mut __map)?;
510 continue;
511 }
512 #[cfg(feature = "strict")]
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::duplicate_field(
515 "useProjectionBasedHeight",
516 ),
517 );
518 }
519 m_useProjectionBasedHeight = _serde::__private::Some(
520 match __A::next_value::<bool>(&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_heightfieldType => {
529 #[cfg(
530 any(feature = "strict", feature = "ignore_duplicates")
531 )]
532 if _serde::__private::Option::is_some(&m_heightfieldType) {
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 "heightfieldType",
542 ),
543 );
544 }
545 m_heightfieldType = _serde::__private::Some(
546 match __A::next_value::<HeightFieldType>(&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_intToFloatScale => {
555 #[cfg(
556 any(feature = "strict", feature = "ignore_duplicates")
557 )]
558 if _serde::__private::Option::is_some(&m_intToFloatScale) {
559 #[cfg(feature = "ignore_duplicates")]
560 {
561 __A::skip_value(&mut __map)?;
562 continue;
563 }
564 #[cfg(feature = "strict")]
565 return _serde::__private::Err(
566 <__A::Error as _serde::de::Error>::duplicate_field(
567 "intToFloatScale",
568 ),
569 );
570 }
571 m_intToFloatScale = _serde::__private::Some(
572 match __A::next_value::<Vector4>(&mut __map) {
573 _serde::__private::Ok(__val) => __val,
574 _serde::__private::Err(__err) => {
575 return _serde::__private::Err(__err);
576 }
577 },
578 );
579 }
580 __Field::m_floatToIntScale => {
581 #[cfg(
582 any(feature = "strict", feature = "ignore_duplicates")
583 )]
584 if _serde::__private::Option::is_some(&m_floatToIntScale) {
585 #[cfg(feature = "ignore_duplicates")]
586 {
587 __A::skip_value(&mut __map)?;
588 continue;
589 }
590 #[cfg(feature = "strict")]
591 return _serde::__private::Err(
592 <__A::Error as _serde::de::Error>::duplicate_field(
593 "floatToIntScale",
594 ),
595 );
596 }
597 m_floatToIntScale = _serde::__private::Some(
598 match __A::next_value::<Vector4>(&mut __map) {
599 _serde::__private::Ok(__val) => __val,
600 _serde::__private::Err(__err) => {
601 return _serde::__private::Err(__err);
602 }
603 },
604 );
605 }
606 __Field::m_floatToIntOffsetFloorCorrected => {
607 #[cfg(
608 any(feature = "strict", feature = "ignore_duplicates")
609 )]
610 if _serde::__private::Option::is_some(
611 &m_floatToIntOffsetFloorCorrected,
612 ) {
613 #[cfg(feature = "ignore_duplicates")]
614 {
615 __A::skip_value(&mut __map)?;
616 continue;
617 }
618 #[cfg(feature = "strict")]
619 return _serde::__private::Err(
620 <__A::Error as _serde::de::Error>::duplicate_field(
621 "floatToIntOffsetFloorCorrected",
622 ),
623 );
624 }
625 m_floatToIntOffsetFloorCorrected = _serde::__private::Some(
626 match __A::next_value::<Vector4>(&mut __map) {
627 _serde::__private::Ok(__val) => __val,
628 _serde::__private::Err(__err) => {
629 return _serde::__private::Err(__err);
630 }
631 },
632 );
633 }
634 __Field::m_extents => {
635 #[cfg(
636 any(feature = "strict", feature = "ignore_duplicates")
637 )]
638 if _serde::__private::Option::is_some(&m_extents) {
639 #[cfg(feature = "ignore_duplicates")]
640 {
641 __A::skip_value(&mut __map)?;
642 continue;
643 }
644 #[cfg(feature = "strict")]
645 return _serde::__private::Err(
646 <__A::Error as _serde::de::Error>::duplicate_field(
647 "extents",
648 ),
649 );
650 }
651 m_extents = _serde::__private::Some(
652 match __A::next_value::<Vector4>(&mut __map) {
653 _serde::__private::Ok(__val) => __val,
654 _serde::__private::Err(__err) => {
655 return _serde::__private::Err(__err);
656 }
657 },
658 );
659 }
660 __Field::m_storage => {
661 #[cfg(
662 any(feature = "strict", feature = "ignore_duplicates")
663 )]
664 if _serde::__private::Option::is_some(&m_storage) {
665 #[cfg(feature = "ignore_duplicates")]
666 {
667 __A::skip_value(&mut __map)?;
668 continue;
669 }
670 #[cfg(feature = "strict")]
671 return _serde::__private::Err(
672 <__A::Error as _serde::de::Error>::duplicate_field(
673 "storage",
674 ),
675 );
676 }
677 m_storage = _serde::__private::Some(
678 match __A::next_value::<Vec<u16>>(&mut __map) {
679 _serde::__private::Ok(__val) => __val,
680 _serde::__private::Err(__err) => {
681 return _serde::__private::Err(__err);
682 }
683 },
684 );
685 }
686 __Field::m_triangleFlip => {
687 #[cfg(
688 any(feature = "strict", feature = "ignore_duplicates")
689 )]
690 if _serde::__private::Option::is_some(&m_triangleFlip) {
691 #[cfg(feature = "ignore_duplicates")]
692 {
693 __A::skip_value(&mut __map)?;
694 continue;
695 }
696 #[cfg(feature = "strict")]
697 return _serde::__private::Err(
698 <__A::Error as _serde::de::Error>::duplicate_field(
699 "triangleFlip",
700 ),
701 );
702 }
703 m_triangleFlip = _serde::__private::Some(
704 match __A::next_value::<bool>(&mut __map) {
705 _serde::__private::Ok(__val) => __val,
706 _serde::__private::Err(__err) => {
707 return _serde::__private::Err(__err);
708 }
709 },
710 );
711 }
712 __Field::m_offset => {
713 #[cfg(
714 any(feature = "strict", feature = "ignore_duplicates")
715 )]
716 if _serde::__private::Option::is_some(&m_offset) {
717 #[cfg(feature = "ignore_duplicates")]
718 {
719 __A::skip_value(&mut __map)?;
720 continue;
721 }
722 #[cfg(feature = "strict")]
723 return _serde::__private::Err(
724 <__A::Error as _serde::de::Error>::duplicate_field("offset"),
725 );
726 }
727 m_offset = _serde::__private::Some(
728 match __A::next_value::<f32>(&mut __map) {
729 _serde::__private::Ok(__val) => __val,
730 _serde::__private::Err(__err) => {
731 return _serde::__private::Err(__err);
732 }
733 },
734 );
735 }
736 __Field::m_scale => {
737 #[cfg(
738 any(feature = "strict", feature = "ignore_duplicates")
739 )]
740 if _serde::__private::Option::is_some(&m_scale) {
741 #[cfg(feature = "ignore_duplicates")]
742 {
743 __A::skip_value(&mut __map)?;
744 continue;
745 }
746 #[cfg(feature = "strict")]
747 return _serde::__private::Err(
748 <__A::Error as _serde::de::Error>::duplicate_field("scale"),
749 );
750 }
751 m_scale = _serde::__private::Some(
752 match __A::next_value::<f32>(&mut __map) {
753 _serde::__private::Ok(__val) => __val,
754 _serde::__private::Err(__err) => {
755 return _serde::__private::Err(__err);
756 }
757 },
758 );
759 }
760 _ => __A::skip_value(&mut __map)?,
761 }
762 }
763 let m_userData = match m_userData {
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("userData"),
769 );
770 #[cfg(not(feature = "strict"))] Default::default()
771 }
772 };
773 let m_xRes = match m_xRes {
774 _serde::__private::Some(__field) => __field,
775 _serde::__private::None => {
776 #[cfg(feature = "strict")]
777 return _serde::__private::Err(
778 <__A::Error as _serde::de::Error>::missing_field("xRes"),
779 );
780 #[cfg(not(feature = "strict"))] Default::default()
781 }
782 };
783 let m_zRes = match m_zRes {
784 _serde::__private::Some(__field) => __field,
785 _serde::__private::None => {
786 #[cfg(feature = "strict")]
787 return _serde::__private::Err(
788 <__A::Error as _serde::de::Error>::missing_field("zRes"),
789 );
790 #[cfg(not(feature = "strict"))] Default::default()
791 }
792 };
793 let m_heightCenter = match m_heightCenter {
794 _serde::__private::Some(__field) => __field,
795 _serde::__private::None => {
796 #[cfg(feature = "strict")]
797 return _serde::__private::Err(
798 <__A::Error as _serde::de::Error>::missing_field(
799 "heightCenter",
800 ),
801 );
802 #[cfg(not(feature = "strict"))] Default::default()
803 }
804 };
805 let m_useProjectionBasedHeight = match m_useProjectionBasedHeight {
806 _serde::__private::Some(__field) => __field,
807 _serde::__private::None => {
808 #[cfg(feature = "strict")]
809 return _serde::__private::Err(
810 <__A::Error as _serde::de::Error>::missing_field(
811 "useProjectionBasedHeight",
812 ),
813 );
814 #[cfg(not(feature = "strict"))] Default::default()
815 }
816 };
817 let m_heightfieldType = match m_heightfieldType {
818 _serde::__private::Some(__field) => __field,
819 _serde::__private::None => {
820 #[cfg(feature = "strict")]
821 return _serde::__private::Err(
822 <__A::Error as _serde::de::Error>::missing_field(
823 "heightfieldType",
824 ),
825 );
826 #[cfg(not(feature = "strict"))] Default::default()
827 }
828 };
829 let m_intToFloatScale = match m_intToFloatScale {
830 _serde::__private::Some(__field) => __field,
831 _serde::__private::None => {
832 #[cfg(feature = "strict")]
833 return _serde::__private::Err(
834 <__A::Error as _serde::de::Error>::missing_field(
835 "intToFloatScale",
836 ),
837 );
838 #[cfg(not(feature = "strict"))] Default::default()
839 }
840 };
841 let m_floatToIntScale = match m_floatToIntScale {
842 _serde::__private::Some(__field) => __field,
843 _serde::__private::None => {
844 #[cfg(feature = "strict")]
845 return _serde::__private::Err(
846 <__A::Error as _serde::de::Error>::missing_field(
847 "floatToIntScale",
848 ),
849 );
850 #[cfg(not(feature = "strict"))] Default::default()
851 }
852 };
853 let m_floatToIntOffsetFloorCorrected = match m_floatToIntOffsetFloorCorrected {
854 _serde::__private::Some(__field) => __field,
855 _serde::__private::None => {
856 #[cfg(feature = "strict")]
857 return _serde::__private::Err(
858 <__A::Error as _serde::de::Error>::missing_field(
859 "floatToIntOffsetFloorCorrected",
860 ),
861 );
862 #[cfg(not(feature = "strict"))] Default::default()
863 }
864 };
865 let m_extents = match m_extents {
866 _serde::__private::Some(__field) => __field,
867 _serde::__private::None => {
868 #[cfg(feature = "strict")]
869 return _serde::__private::Err(
870 <__A::Error as _serde::de::Error>::missing_field("extents"),
871 );
872 #[cfg(not(feature = "strict"))] Default::default()
873 }
874 };
875 let m_storage = match m_storage {
876 _serde::__private::Some(__field) => __field,
877 _serde::__private::None => {
878 #[cfg(feature = "strict")]
879 return _serde::__private::Err(
880 <__A::Error as _serde::de::Error>::missing_field("storage"),
881 );
882 #[cfg(not(feature = "strict"))] Default::default()
883 }
884 };
885 let m_triangleFlip = match m_triangleFlip {
886 _serde::__private::Some(__field) => __field,
887 _serde::__private::None => {
888 #[cfg(feature = "strict")]
889 return _serde::__private::Err(
890 <__A::Error as _serde::de::Error>::missing_field(
891 "triangleFlip",
892 ),
893 );
894 #[cfg(not(feature = "strict"))] Default::default()
895 }
896 };
897 let m_offset = match m_offset {
898 _serde::__private::Some(__field) => __field,
899 _serde::__private::None => {
900 #[cfg(feature = "strict")]
901 return _serde::__private::Err(
902 <__A::Error as _serde::de::Error>::missing_field("offset"),
903 );
904 #[cfg(not(feature = "strict"))] Default::default()
905 }
906 };
907 let m_scale = match m_scale {
908 _serde::__private::Some(__field) => __field,
909 _serde::__private::None => {
910 #[cfg(feature = "strict")]
911 return _serde::__private::Err(
912 <__A::Error as _serde::de::Error>::missing_field("scale"),
913 );
914 #[cfg(not(feature = "strict"))] Default::default()
915 }
916 };
917 let __ptr = None;
918 let parent = hkBaseObject { __ptr };
919 let parent = hkReferencedObject {
920 __ptr,
921 parent,
922 ..Default::default()
923 };
924 let parent = hkpShape {
925 __ptr,
926 parent,
927 m_userData,
928 ..Default::default()
929 };
930 let parent = hkpHeightFieldShape {
931 __ptr,
932 parent,
933 };
934 let parent = hkpSampledHeightFieldShape {
935 __ptr,
936 parent,
937 m_xRes,
938 m_zRes,
939 m_heightCenter,
940 m_useProjectionBasedHeight,
941 m_heightfieldType,
942 m_intToFloatScale,
943 m_floatToIntScale,
944 m_floatToIntOffsetFloorCorrected,
945 m_extents,
946 };
947 let __ptr = __A::class_ptr(&mut __map);
948 _serde::__private::Ok(hkpCompressedSampledHeightFieldShape {
949 __ptr,
950 parent,
951 m_storage,
952 m_triangleFlip,
953 m_offset,
954 m_scale,
955 })
956 }
957 }
958 const FIELDS: &[&str] = &["storage", "triangleFlip", "offset", "scale"];
959 _serde::Deserializer::deserialize_struct(
960 deserializer,
961 "hkpCompressedSampledHeightFieldShape",
962 FIELDS,
963 __hkpCompressedSampledHeightFieldShapeVisitor {
964 marker: _serde::__private::PhantomData::<
965 hkpCompressedSampledHeightFieldShape,
966 >,
967 lifetime: _serde::__private::PhantomData,
968 },
969 )
970 }
971 }
972};