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