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