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