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