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