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