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