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