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