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 hkpTriSampledHeightFieldCollection {
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: hkpShapeCollection,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "heightfield"))]
35 #[cfg_attr(feature = "serde", serde(rename = "heightfield"))]
36 pub m_heightfield: Pointer,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "childSize"))]
43 #[cfg_attr(feature = "serde", serde(rename = "childSize"))]
44 pub m_childSize: i32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "radius"))]
50 #[cfg_attr(feature = "serde", serde(rename = "radius"))]
51 pub m_radius: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "weldingInfo"))]
57 #[cfg_attr(feature = "serde", serde(rename = "weldingInfo"))]
58 pub m_weldingInfo: Vec<u16>,
59 #[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 #[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};