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