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 hkpLinkedCollidable {
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 pub parent: hkpCollidable,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "collisionEntries"))]
36 #[cfg_attr(feature = "serde", serde(rename = "collisionEntries"))]
37 pub m_collisionEntries: Vec<()>,
38}
39const _: () = {
40 use havok_serde as _serde;
41 impl _serde::HavokClass for hkpLinkedCollidable {
42 #[inline]
43 fn name(&self) -> &'static str {
44 "hkpLinkedCollidable"
45 }
46 #[inline]
47 fn signature(&self) -> _serde::__private::Signature {
48 _serde::__private::Signature::new(0xe1a81497)
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_shape.get());
54 v.push(self.parent.parent.m_motion.get());
55 v.push(self.parent.parent.m_parent.get());
56 v.extend(self.parent.m_broadPhaseHandle.deps_indexes());
57 v.extend(self.parent.m_boundingVolumeData.deps_indexes());
58 v
59 }
60 }
61 impl _serde::Serialize for hkpLinkedCollidable {
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(0xe1a81497)));
69 let mut serializer = __serializer
70 .serialize_struct("hkpLinkedCollidable", class_meta, (92u64, 128u64))?;
71 serializer.serialize_field("shape", &self.parent.parent.m_shape)?;
72 serializer.serialize_field("shapeKey", &self.parent.parent.m_shapeKey)?;
73 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
74 serializer.skip_field("motion", &self.parent.parent.m_motion)?;
75 serializer.skip_field("parent", &self.parent.parent.m_parent)?;
76 serializer.skip_field("ownerOffset", &self.parent.m_ownerOffset)?;
77 serializer
78 .serialize_field(
79 "forceCollideOntoPpu",
80 &self.parent.m_forceCollideOntoPpu,
81 )?;
82 serializer.skip_field("shapeSizeOnSpu", &self.parent.m_shapeSizeOnSpu)?;
83 serializer
84 .serialize_field("broadPhaseHandle", &self.parent.m_broadPhaseHandle)?;
85 serializer
86 .skip_field("boundingVolumeData", &self.parent.m_boundingVolumeData)?;
87 serializer
88 .serialize_field(
89 "allowedPenetrationDepth",
90 &self.parent.m_allowedPenetrationDepth,
91 )?;
92 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
93 serializer
94 .skip_array_field(
95 "collisionEntries",
96 &self.m_collisionEntries,
97 TypeSize::NonPtr,
98 )?;
99 serializer.end()
100 }
101 }
102};
103#[doc(hidden)]
104#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
105const _: () = {
106 use havok_serde as _serde;
107 #[automatically_derived]
108 impl<'de> _serde::Deserialize<'de> for hkpLinkedCollidable {
109 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
110 where
111 __D: _serde::Deserializer<'de>,
112 {
113 #[allow(non_camel_case_types)]
114 enum __Field {
115 m_shape,
116 m_shapeKey,
117 m_forceCollideOntoPpu,
118 m_broadPhaseHandle,
119 m_allowedPenetrationDepth,
120 __ignore,
121 }
122 struct __FieldVisitor;
123 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
124 type Value = __Field;
125 fn expecting(
126 &self,
127 __formatter: &mut core::fmt::Formatter,
128 ) -> core::fmt::Result {
129 core::fmt::Formatter::write_str(__formatter, "field identifier")
130 }
131 #[allow(clippy::match_single_binding)]
133 #[allow(clippy::reversed_empty_ranges)]
134 #[allow(clippy::single_match)]
135 fn visit_key<__E>(
136 self,
137 __value: &str,
138 ) -> core::result::Result<Self::Value, __E>
139 where
140 __E: _serde::de::Error,
141 {
142 match __value {
143 "shape" => Ok(__Field::m_shape),
144 "shapeKey" => Ok(__Field::m_shapeKey),
145 "forceCollideOntoPpu" => Ok(__Field::m_forceCollideOntoPpu),
146 "broadPhaseHandle" => Ok(__Field::m_broadPhaseHandle),
147 "allowedPenetrationDepth" => {
148 Ok(__Field::m_allowedPenetrationDepth)
149 }
150 _ => Ok(__Field::__ignore),
151 }
152 }
153 }
154 impl<'de> _serde::Deserialize<'de> for __Field {
155 #[inline]
156 fn deserialize<__D>(
157 __deserializer: __D,
158 ) -> core::result::Result<Self, __D::Error>
159 where
160 __D: _serde::Deserializer<'de>,
161 {
162 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
163 }
164 }
165 struct __hkpLinkedCollidableVisitor<'de> {
166 marker: _serde::__private::PhantomData<hkpLinkedCollidable>,
167 lifetime: _serde::__private::PhantomData<&'de ()>,
168 }
169 #[allow(clippy::match_single_binding)]
170 #[allow(clippy::reversed_empty_ranges)]
171 #[allow(clippy::single_match)]
172 impl<'de> _serde::de::Visitor<'de> for __hkpLinkedCollidableVisitor<'de> {
173 type Value = hkpLinkedCollidable;
174 fn expecting(
175 &self,
176 __formatter: &mut core::fmt::Formatter,
177 ) -> core::fmt::Result {
178 core::fmt::Formatter::write_str(
179 __formatter,
180 "struct hkpLinkedCollidable",
181 )
182 }
183 fn visit_struct_for_bytes<__A>(
184 self,
185 mut __map: __A,
186 ) -> _serde::__private::Result<Self::Value, __A::Error>
187 where
188 __A: _serde::de::MapAccess<'de>,
189 {
190 let __ptr = __A::class_ptr(&mut __map);
191 let parent = __A::parent_value(&mut __map)?;
192 let mut m_collisionEntries: _serde::__private::Option<Vec<()>> = _serde::__private::None;
193 for i in 0..1usize {
194 match i {
195 0usize => {
196 if _serde::__private::Option::is_some(&m_collisionEntries) {
197 return _serde::__private::Err(
198 <__A::Error as _serde::de::Error>::duplicate_field(
199 "collisionEntries",
200 ),
201 );
202 }
203 m_collisionEntries = _serde::__private::Some(
204 match __A::next_value::<Vec<()>>(&mut __map) {
205 _serde::__private::Ok(__val) => __val,
206 _serde::__private::Err(__err) => {
207 return _serde::__private::Err(__err);
208 }
209 },
210 );
211 }
212 _ => {}
213 }
214 }
215 let m_collisionEntries = match m_collisionEntries {
216 _serde::__private::Some(__field) => __field,
217 _serde::__private::None => {
218 return _serde::__private::Err(
219 <__A::Error as _serde::de::Error>::missing_field(
220 "collisionEntries",
221 ),
222 );
223 }
224 };
225 _serde::__private::Ok(hkpLinkedCollidable {
226 __ptr,
227 parent,
228 m_collisionEntries,
229 })
230 }
231 #[allow(clippy::manual_unwrap_or_default)]
232 fn visit_struct<__A>(
233 self,
234 mut __map: __A,
235 ) -> _serde::__private::Result<Self::Value, __A::Error>
236 where
237 __A: _serde::de::MapAccess<'de>,
238 {
239 let mut m_shape: _serde::__private::Option<Pointer> = _serde::__private::None;
240 let mut m_shapeKey: _serde::__private::Option<u32> = _serde::__private::None;
241 let mut m_forceCollideOntoPpu: _serde::__private::Option<u8> = _serde::__private::None;
242 let mut m_broadPhaseHandle: _serde::__private::Option<
243 hkpTypedBroadPhaseHandle,
244 > = _serde::__private::None;
245 let mut m_allowedPenetrationDepth: _serde::__private::Option<f32> = _serde::__private::None;
246 while let _serde::__private::Some(__key) = {
247 __A::next_key::<__Field>(&mut __map)?
248 } {
249 match __key {
250 __Field::m_shape => {
251 #[cfg(
252 any(feature = "strict", feature = "ignore_duplicates")
253 )]
254 if _serde::__private::Option::is_some(&m_shape) {
255 #[cfg(feature = "ignore_duplicates")]
256 {
257 __A::skip_value(&mut __map)?;
258 continue;
259 }
260 #[cfg(feature = "strict")]
261 return _serde::__private::Err(
262 <__A::Error as _serde::de::Error>::duplicate_field("shape"),
263 );
264 }
265 m_shape = _serde::__private::Some(
266 match __A::next_value::<Pointer>(&mut __map) {
267 _serde::__private::Ok(__val) => __val,
268 _serde::__private::Err(__err) => {
269 return _serde::__private::Err(__err);
270 }
271 },
272 );
273 }
274 __Field::m_shapeKey => {
275 #[cfg(
276 any(feature = "strict", feature = "ignore_duplicates")
277 )]
278 if _serde::__private::Option::is_some(&m_shapeKey) {
279 #[cfg(feature = "ignore_duplicates")]
280 {
281 __A::skip_value(&mut __map)?;
282 continue;
283 }
284 #[cfg(feature = "strict")]
285 return _serde::__private::Err(
286 <__A::Error as _serde::de::Error>::duplicate_field(
287 "shapeKey",
288 ),
289 );
290 }
291 m_shapeKey = _serde::__private::Some(
292 match __A::next_value::<u32>(&mut __map) {
293 _serde::__private::Ok(__val) => __val,
294 _serde::__private::Err(__err) => {
295 return _serde::__private::Err(__err);
296 }
297 },
298 );
299 }
300 __Field::m_forceCollideOntoPpu => {
301 #[cfg(
302 any(feature = "strict", feature = "ignore_duplicates")
303 )]
304 if _serde::__private::Option::is_some(
305 &m_forceCollideOntoPpu,
306 ) {
307 #[cfg(feature = "ignore_duplicates")]
308 {
309 __A::skip_value(&mut __map)?;
310 continue;
311 }
312 #[cfg(feature = "strict")]
313 return _serde::__private::Err(
314 <__A::Error as _serde::de::Error>::duplicate_field(
315 "forceCollideOntoPpu",
316 ),
317 );
318 }
319 m_forceCollideOntoPpu = _serde::__private::Some(
320 match __A::next_value::<u8>(&mut __map) {
321 _serde::__private::Ok(__val) => __val,
322 _serde::__private::Err(__err) => {
323 return _serde::__private::Err(__err);
324 }
325 },
326 );
327 }
328 __Field::m_broadPhaseHandle => {
329 #[cfg(
330 any(feature = "strict", feature = "ignore_duplicates")
331 )]
332 if _serde::__private::Option::is_some(&m_broadPhaseHandle) {
333 #[cfg(feature = "ignore_duplicates")]
334 {
335 __A::skip_value(&mut __map)?;
336 continue;
337 }
338 #[cfg(feature = "strict")]
339 return _serde::__private::Err(
340 <__A::Error as _serde::de::Error>::duplicate_field(
341 "broadPhaseHandle",
342 ),
343 );
344 }
345 m_broadPhaseHandle = _serde::__private::Some(
346 match __A::next_value::<
347 hkpTypedBroadPhaseHandle,
348 >(&mut __map) {
349 _serde::__private::Ok(__val) => __val,
350 _serde::__private::Err(__err) => {
351 return _serde::__private::Err(__err);
352 }
353 },
354 );
355 }
356 __Field::m_allowedPenetrationDepth => {
357 #[cfg(
358 any(feature = "strict", feature = "ignore_duplicates")
359 )]
360 if _serde::__private::Option::is_some(
361 &m_allowedPenetrationDepth,
362 ) {
363 #[cfg(feature = "ignore_duplicates")]
364 {
365 __A::skip_value(&mut __map)?;
366 continue;
367 }
368 #[cfg(feature = "strict")]
369 return _serde::__private::Err(
370 <__A::Error as _serde::de::Error>::duplicate_field(
371 "allowedPenetrationDepth",
372 ),
373 );
374 }
375 m_allowedPenetrationDepth = _serde::__private::Some(
376 match __A::next_value::<f32>(&mut __map) {
377 _serde::__private::Ok(__val) => __val,
378 _serde::__private::Err(__err) => {
379 return _serde::__private::Err(__err);
380 }
381 },
382 );
383 }
384 _ => __A::skip_value(&mut __map)?,
385 }
386 }
387 let m_shape = match m_shape {
388 _serde::__private::Some(__field) => __field,
389 _serde::__private::None => {
390 #[cfg(feature = "strict")]
391 return _serde::__private::Err(
392 <__A::Error as _serde::de::Error>::missing_field("shape"),
393 );
394 #[cfg(not(feature = "strict"))] Default::default()
395 }
396 };
397 let m_shapeKey = match m_shapeKey {
398 _serde::__private::Some(__field) => __field,
399 _serde::__private::None => {
400 #[cfg(feature = "strict")]
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::missing_field("shapeKey"),
403 );
404 #[cfg(not(feature = "strict"))] Default::default()
405 }
406 };
407 let m_forceCollideOntoPpu = match m_forceCollideOntoPpu {
408 _serde::__private::Some(__field) => __field,
409 _serde::__private::None => {
410 #[cfg(feature = "strict")]
411 return _serde::__private::Err(
412 <__A::Error as _serde::de::Error>::missing_field(
413 "forceCollideOntoPpu",
414 ),
415 );
416 #[cfg(not(feature = "strict"))] Default::default()
417 }
418 };
419 let m_broadPhaseHandle = match m_broadPhaseHandle {
420 _serde::__private::Some(__field) => __field,
421 _serde::__private::None => {
422 #[cfg(feature = "strict")]
423 return _serde::__private::Err(
424 <__A::Error as _serde::de::Error>::missing_field(
425 "broadPhaseHandle",
426 ),
427 );
428 #[cfg(not(feature = "strict"))] Default::default()
429 }
430 };
431 let m_allowedPenetrationDepth = match m_allowedPenetrationDepth {
432 _serde::__private::Some(__field) => __field,
433 _serde::__private::None => {
434 #[cfg(feature = "strict")]
435 return _serde::__private::Err(
436 <__A::Error as _serde::de::Error>::missing_field(
437 "allowedPenetrationDepth",
438 ),
439 );
440 #[cfg(not(feature = "strict"))] Default::default()
441 }
442 };
443 let __ptr = None;
444 let parent = hkpCdBody {
445 __ptr,
446 m_shape,
447 m_shapeKey,
448 ..Default::default()
449 };
450 let parent = hkpCollidable {
451 __ptr,
452 parent,
453 m_forceCollideOntoPpu,
454 m_broadPhaseHandle,
455 m_allowedPenetrationDepth,
456 ..Default::default()
457 };
458 let __ptr = __A::class_ptr(&mut __map);
459 _serde::__private::Ok(hkpLinkedCollidable {
460 __ptr,
461 parent,
462 ..Default::default()
463 })
464 }
465 }
466 const FIELDS: &[&str] = &["collisionEntries"];
467 _serde::Deserializer::deserialize_struct(
468 deserializer,
469 "hkpLinkedCollidable",
470 FIELDS,
471 __hkpLinkedCollidableVisitor {
472 marker: _serde::__private::PhantomData::<hkpLinkedCollidable>,
473 lifetime: _serde::__private::PhantomData,
474 },
475 )
476 }
477 }
478};