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