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