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 hkpSimpleShapePhantom<'a> {
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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkpShapePhantom<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "collisionDetails"))]
37 #[cfg_attr(feature = "serde", serde(rename = "collisionDetails"))]
38 pub m_collisionDetails: Vec<hkpSimpleShapePhantomCollisionDetail>,
39 #[cfg_attr(feature = "json_schema", schemars(rename = "orderDirty"))]
45 #[cfg_attr(feature = "serde", serde(rename = "orderDirty"))]
46 pub m_orderDirty: bool,
47}
48const _: () = {
49 use havok_serde as _serde;
50 impl<'a> _serde::HavokClass for hkpSimpleShapePhantom<'a> {
51 #[inline]
52 fn name(&self) -> &'static str {
53 "hkpSimpleShapePhantom"
54 }
55 #[inline]
56 fn signature(&self) -> _serde::__private::Signature {
57 _serde::__private::Signature::new(0x32a2a8a8)
58 }
59 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
60 fn deps_indexes(&self) -> Vec<usize> {
61 let mut v = Vec::new();
62 v.push(self.parent.parent.parent.m_world.get());
63 v.extend(self.parent.parent.parent.m_collidable.deps_indexes());
64 v.extend(self.parent.parent.parent.m_multiThreadCheck.deps_indexes());
65 v.extend(
66 self
67 .parent
68 .parent
69 .parent
70 .m_properties
71 .iter()
72 .flat_map(|class| class.deps_indexes())
73 .collect::<Vec<usize>>(),
74 );
75 v.push(self.parent.parent.parent.m_treeData.get());
76 v.extend(self.parent.parent.m_overlapListeners.iter().map(|ptr| ptr.get()));
77 v.extend(self.parent.parent.m_phantomListeners.iter().map(|ptr| ptr.get()));
78 v.extend(self.parent.m_motionState.deps_indexes());
79 v.extend(
80 self
81 .m_collisionDetails
82 .iter()
83 .flat_map(|class| class.deps_indexes())
84 .collect::<Vec<usize>>(),
85 );
86 v
87 }
88 }
89 impl<'a> _serde::Serialize for hkpSimpleShapePhantom<'a> {
90 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
91 where
92 S: _serde::ser::Serializer,
93 {
94 let class_meta = self
95 .__ptr
96 .map(|name| (name, _serde::__private::Signature::new(0x32a2a8a8)));
97 let mut serializer = __serializer
98 .serialize_struct(
99 "hkpSimpleShapePhantom",
100 class_meta,
101 (368u64, 448u64),
102 )?;
103 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
104 serializer
105 .skip_field(
106 "memSizeAndFlags",
107 &self.parent.parent.parent.parent.m_memSizeAndFlags,
108 )?;
109 serializer
110 .skip_field(
111 "referenceCount",
112 &self.parent.parent.parent.parent.m_referenceCount,
113 )?;
114 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
115 serializer.skip_field("world", &self.parent.parent.parent.m_world)?;
116 serializer
117 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
118 serializer
119 .serialize_field("collidable", &self.parent.parent.parent.m_collidable)?;
120 serializer
121 .serialize_field(
122 "multiThreadCheck",
123 &self.parent.parent.parent.m_multiThreadCheck,
124 )?;
125 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
126 serializer.serialize_field("name", &self.parent.parent.parent.m_name)?;
127 serializer
128 .serialize_array_field(
129 "properties",
130 &self.parent.parent.parent.m_properties,
131 TypeSize::Struct {
132 size_x86: 16u64,
133 size_x86_64: 16u64,
134 },
135 )?;
136 serializer.skip_field("treeData", &self.parent.parent.parent.m_treeData)?;
137 serializer
138 .skip_array_field(
139 "overlapListeners",
140 &self.parent.parent.m_overlapListeners,
141 TypeSize::NonPtr,
142 )?;
143 serializer
144 .skip_array_field(
145 "phantomListeners",
146 &self.parent.parent.m_phantomListeners,
147 TypeSize::NonPtr,
148 )?;
149 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 0usize].as_slice())?;
150 serializer.serialize_field("motionState", &self.parent.m_motionState)?;
151 serializer
152 .skip_array_field(
153 "collisionDetails",
154 &self.m_collisionDetails,
155 TypeSize::Struct {
156 size_x86: 4u64,
157 size_x86_64: 8u64,
158 },
159 )?;
160 serializer.skip_field("orderDirty", &self.m_orderDirty)?;
161 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 15usize].as_slice())?;
162 serializer.end()
163 }
164 }
165};
166#[doc(hidden)]
167#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
168const _: () = {
169 use havok_serde as _serde;
170 #[automatically_derived]
171 impl<'de> _serde::Deserialize<'de> for hkpSimpleShapePhantom<'de> {
172 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
173 where
174 __D: _serde::Deserializer<'de>,
175 {
176 #[allow(non_camel_case_types)]
177 enum __Field {
178 m_userData,
179 m_collidable,
180 m_multiThreadCheck,
181 m_name,
182 m_properties,
183 m_motionState,
184 __ignore,
185 }
186 struct __FieldVisitor;
187 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
188 type Value = __Field;
189 fn expecting(
190 &self,
191 __formatter: &mut core::fmt::Formatter,
192 ) -> core::fmt::Result {
193 core::fmt::Formatter::write_str(__formatter, "field identifier")
194 }
195 #[allow(clippy::match_single_binding)]
197 #[allow(clippy::reversed_empty_ranges)]
198 #[allow(clippy::single_match)]
199 fn visit_key<__E>(
200 self,
201 __value: &str,
202 ) -> core::result::Result<Self::Value, __E>
203 where
204 __E: _serde::de::Error,
205 {
206 match __value {
207 "userData" => Ok(__Field::m_userData),
208 "collidable" => Ok(__Field::m_collidable),
209 "multiThreadCheck" => Ok(__Field::m_multiThreadCheck),
210 "name" => Ok(__Field::m_name),
211 "properties" => Ok(__Field::m_properties),
212 "motionState" => Ok(__Field::m_motionState),
213 _ => Ok(__Field::__ignore),
214 }
215 }
216 }
217 impl<'de> _serde::Deserialize<'de> for __Field {
218 #[inline]
219 fn deserialize<__D>(
220 __deserializer: __D,
221 ) -> core::result::Result<Self, __D::Error>
222 where
223 __D: _serde::Deserializer<'de>,
224 {
225 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
226 }
227 }
228 struct __hkpSimpleShapePhantomVisitor<'de> {
229 marker: _serde::__private::PhantomData<hkpSimpleShapePhantom<'de>>,
230 lifetime: _serde::__private::PhantomData<&'de ()>,
231 }
232 #[allow(clippy::match_single_binding)]
233 #[allow(clippy::reversed_empty_ranges)]
234 #[allow(clippy::single_match)]
235 impl<'de> _serde::de::Visitor<'de> for __hkpSimpleShapePhantomVisitor<'de> {
236 type Value = hkpSimpleShapePhantom<'de>;
237 fn expecting(
238 &self,
239 __formatter: &mut core::fmt::Formatter,
240 ) -> core::fmt::Result {
241 core::fmt::Formatter::write_str(
242 __formatter,
243 "struct hkpSimpleShapePhantom",
244 )
245 }
246 fn visit_struct_for_bytes<__A>(
247 self,
248 mut __map: __A,
249 ) -> _serde::__private::Result<Self::Value, __A::Error>
250 where
251 __A: _serde::de::MapAccess<'de>,
252 {
253 let __ptr = __A::class_ptr(&mut __map);
254 let parent = __A::parent_value(&mut __map)?;
255 let mut m_collisionDetails: _serde::__private::Option<
256 Vec<hkpSimpleShapePhantomCollisionDetail>,
257 > = _serde::__private::None;
258 let mut m_orderDirty: _serde::__private::Option<bool> = _serde::__private::None;
259 for i in 0..2usize {
260 match i {
261 0usize => {
262 if _serde::__private::Option::is_some(&m_collisionDetails) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "collisionDetails",
266 ),
267 );
268 }
269 m_collisionDetails = _serde::__private::Some(
270 match __A::next_value::<
271 Vec<hkpSimpleShapePhantomCollisionDetail>,
272 >(&mut __map) {
273 _serde::__private::Ok(__val) => __val,
274 _serde::__private::Err(__err) => {
275 return _serde::__private::Err(__err);
276 }
277 },
278 );
279 }
280 1usize => {
281 if _serde::__private::Option::is_some(&m_orderDirty) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field(
284 "orderDirty",
285 ),
286 );
287 }
288 m_orderDirty = _serde::__private::Some(
289 match __A::next_value::<bool>(&mut __map) {
290 _serde::__private::Ok(__val) => __val,
291 _serde::__private::Err(__err) => {
292 return _serde::__private::Err(__err);
293 }
294 },
295 );
296 }
297 _ => {}
298 }
299 }
300 __A::pad(&mut __map, 3usize, 15usize)?;
301 let m_collisionDetails = match m_collisionDetails {
302 _serde::__private::Some(__field) => __field,
303 _serde::__private::None => {
304 return _serde::__private::Err(
305 <__A::Error as _serde::de::Error>::missing_field(
306 "collisionDetails",
307 ),
308 );
309 }
310 };
311 let m_orderDirty = match m_orderDirty {
312 _serde::__private::Some(__field) => __field,
313 _serde::__private::None => {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::missing_field(
316 "orderDirty",
317 ),
318 );
319 }
320 };
321 _serde::__private::Ok(hkpSimpleShapePhantom {
322 __ptr,
323 parent,
324 m_collisionDetails,
325 m_orderDirty,
326 })
327 }
328 #[allow(clippy::manual_unwrap_or_default)]
329 fn visit_struct<__A>(
330 self,
331 mut __map: __A,
332 ) -> _serde::__private::Result<Self::Value, __A::Error>
333 where
334 __A: _serde::de::MapAccess<'de>,
335 {
336 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
337 let mut m_collidable: _serde::__private::Option<
338 hkpLinkedCollidable,
339 > = _serde::__private::None;
340 let mut m_multiThreadCheck: _serde::__private::Option<
341 hkMultiThreadCheck,
342 > = _serde::__private::None;
343 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
344 let mut m_properties: _serde::__private::Option<Vec<hkpProperty>> = _serde::__private::None;
345 let mut m_motionState: _serde::__private::Option<hkMotionState> = _serde::__private::None;
346 while let _serde::__private::Some(__key) = {
347 __A::next_key::<__Field>(&mut __map)?
348 } {
349 match __key {
350 __Field::m_userData => {
351 #[cfg(
352 any(feature = "strict", feature = "ignore_duplicates")
353 )]
354 if _serde::__private::Option::is_some(&m_userData) {
355 #[cfg(feature = "ignore_duplicates")]
356 {
357 __A::skip_value(&mut __map)?;
358 continue;
359 }
360 #[cfg(feature = "strict")]
361 return _serde::__private::Err(
362 <__A::Error as _serde::de::Error>::duplicate_field(
363 "userData",
364 ),
365 );
366 }
367 m_userData = _serde::__private::Some(
368 match __A::next_value::<Ulong>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 __Field::m_collidable => {
377 #[cfg(
378 any(feature = "strict", feature = "ignore_duplicates")
379 )]
380 if _serde::__private::Option::is_some(&m_collidable) {
381 #[cfg(feature = "ignore_duplicates")]
382 {
383 __A::skip_value(&mut __map)?;
384 continue;
385 }
386 #[cfg(feature = "strict")]
387 return _serde::__private::Err(
388 <__A::Error as _serde::de::Error>::duplicate_field(
389 "collidable",
390 ),
391 );
392 }
393 m_collidable = _serde::__private::Some(
394 match __A::next_value::<hkpLinkedCollidable>(&mut __map) {
395 _serde::__private::Ok(__val) => __val,
396 _serde::__private::Err(__err) => {
397 return _serde::__private::Err(__err);
398 }
399 },
400 );
401 }
402 __Field::m_multiThreadCheck => {
403 #[cfg(
404 any(feature = "strict", feature = "ignore_duplicates")
405 )]
406 if _serde::__private::Option::is_some(&m_multiThreadCheck) {
407 #[cfg(feature = "ignore_duplicates")]
408 {
409 __A::skip_value(&mut __map)?;
410 continue;
411 }
412 #[cfg(feature = "strict")]
413 return _serde::__private::Err(
414 <__A::Error as _serde::de::Error>::duplicate_field(
415 "multiThreadCheck",
416 ),
417 );
418 }
419 m_multiThreadCheck = _serde::__private::Some(
420 match __A::next_value::<hkMultiThreadCheck>(&mut __map) {
421 _serde::__private::Ok(__val) => __val,
422 _serde::__private::Err(__err) => {
423 return _serde::__private::Err(__err);
424 }
425 },
426 );
427 }
428 __Field::m_name => {
429 #[cfg(
430 any(feature = "strict", feature = "ignore_duplicates")
431 )]
432 if _serde::__private::Option::is_some(&m_name) {
433 #[cfg(feature = "ignore_duplicates")]
434 {
435 __A::skip_value(&mut __map)?;
436 continue;
437 }
438 #[cfg(feature = "strict")]
439 return _serde::__private::Err(
440 <__A::Error as _serde::de::Error>::duplicate_field("name"),
441 );
442 }
443 m_name = _serde::__private::Some(
444 match __A::next_value::<StringPtr<'de>>(&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_properties => {
453 #[cfg(
454 any(feature = "strict", feature = "ignore_duplicates")
455 )]
456 if _serde::__private::Option::is_some(&m_properties) {
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 "properties",
466 ),
467 );
468 }
469 m_properties = _serde::__private::Some(
470 match __A::next_value::<Vec<hkpProperty>>(&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_motionState => {
479 #[cfg(
480 any(feature = "strict", feature = "ignore_duplicates")
481 )]
482 if _serde::__private::Option::is_some(&m_motionState) {
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 "motionState",
492 ),
493 );
494 }
495 m_motionState = _serde::__private::Some(
496 match __A::next_value::<hkMotionState>(&mut __map) {
497 _serde::__private::Ok(__val) => __val,
498 _serde::__private::Err(__err) => {
499 return _serde::__private::Err(__err);
500 }
501 },
502 );
503 }
504 _ => __A::skip_value(&mut __map)?,
505 }
506 }
507 let m_userData = match m_userData {
508 _serde::__private::Some(__field) => __field,
509 _serde::__private::None => {
510 #[cfg(feature = "strict")]
511 return _serde::__private::Err(
512 <__A::Error as _serde::de::Error>::missing_field("userData"),
513 );
514 #[cfg(not(feature = "strict"))] Default::default()
515 }
516 };
517 let m_collidable = match m_collidable {
518 _serde::__private::Some(__field) => __field,
519 _serde::__private::None => {
520 #[cfg(feature = "strict")]
521 return _serde::__private::Err(
522 <__A::Error as _serde::de::Error>::missing_field(
523 "collidable",
524 ),
525 );
526 #[cfg(not(feature = "strict"))] Default::default()
527 }
528 };
529 let m_multiThreadCheck = match m_multiThreadCheck {
530 _serde::__private::Some(__field) => __field,
531 _serde::__private::None => {
532 #[cfg(feature = "strict")]
533 return _serde::__private::Err(
534 <__A::Error as _serde::de::Error>::missing_field(
535 "multiThreadCheck",
536 ),
537 );
538 #[cfg(not(feature = "strict"))] Default::default()
539 }
540 };
541 let m_name = match m_name {
542 _serde::__private::Some(__field) => __field,
543 _serde::__private::None => {
544 #[cfg(feature = "strict")]
545 return _serde::__private::Err(
546 <__A::Error as _serde::de::Error>::missing_field("name"),
547 );
548 #[cfg(not(feature = "strict"))] Default::default()
549 }
550 };
551 let m_properties = match m_properties {
552 _serde::__private::Some(__field) => __field,
553 _serde::__private::None => {
554 #[cfg(feature = "strict")]
555 return _serde::__private::Err(
556 <__A::Error as _serde::de::Error>::missing_field(
557 "properties",
558 ),
559 );
560 #[cfg(not(feature = "strict"))] Default::default()
561 }
562 };
563 let m_motionState = match m_motionState {
564 _serde::__private::Some(__field) => __field,
565 _serde::__private::None => {
566 #[cfg(feature = "strict")]
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::missing_field(
569 "motionState",
570 ),
571 );
572 #[cfg(not(feature = "strict"))] Default::default()
573 }
574 };
575 let __ptr = None;
576 let parent = hkBaseObject { __ptr };
577 let parent = hkReferencedObject {
578 __ptr,
579 parent,
580 ..Default::default()
581 };
582 let parent = hkpWorldObject {
583 __ptr,
584 parent,
585 m_userData,
586 m_collidable,
587 m_multiThreadCheck,
588 m_name,
589 m_properties,
590 ..Default::default()
591 };
592 let parent = hkpPhantom {
593 __ptr,
594 parent,
595 ..Default::default()
596 };
597 let parent = hkpShapePhantom {
598 __ptr,
599 parent,
600 m_motionState,
601 };
602 let __ptr = __A::class_ptr(&mut __map);
603 _serde::__private::Ok(hkpSimpleShapePhantom {
604 __ptr,
605 parent,
606 ..Default::default()
607 })
608 }
609 }
610 const FIELDS: &[&str] = &["collisionDetails", "orderDirty"];
611 _serde::Deserializer::deserialize_struct(
612 deserializer,
613 "hkpSimpleShapePhantom",
614 FIELDS,
615 __hkpSimpleShapePhantomVisitor {
616 marker: _serde::__private::PhantomData::<hkpSimpleShapePhantom>,
617 lifetime: _serde::__private::PhantomData,
618 },
619 )
620 }
621 }
622};