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