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 hkpVehicleDefaultSteering {
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: hkpVehicleSteering,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "maxSteeringAngle"))]
35 #[cfg_attr(feature = "serde", serde(rename = "maxSteeringAngle"))]
36 pub m_maxSteeringAngle: f32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "maxSpeedFullSteeringAngle"))]
42 #[cfg_attr(feature = "serde", serde(rename = "maxSpeedFullSteeringAngle"))]
43 pub m_maxSpeedFullSteeringAngle: f32,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "doesWheelSteer"))]
49 #[cfg_attr(feature = "serde", serde(rename = "doesWheelSteer"))]
50 pub m_doesWheelSteer: Vec<bool>,
51}
52const _: () = {
53 use havok_serde as _serde;
54 impl _serde::HavokClass for hkpVehicleDefaultSteering {
55 #[inline]
56 fn name(&self) -> &'static str {
57 "hkpVehicleDefaultSteering"
58 }
59 #[inline]
60 fn signature(&self) -> _serde::__private::Signature {
61 _serde::__private::Signature::new(0x8f0411c8)
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
67 }
68 }
69 impl _serde::Serialize for hkpVehicleDefaultSteering {
70 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
71 where
72 S: _serde::ser::Serializer,
73 {
74 let class_meta = self
75 .__ptr
76 .map(|name| (name, _serde::__private::Signature::new(0x8f0411c8)));
77 let mut serializer = __serializer
78 .serialize_struct(
79 "hkpVehicleDefaultSteering",
80 class_meta,
81 (28u64, 40u64),
82 )?;
83 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
84 serializer
85 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
86 serializer
87 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
88 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
89 serializer.serialize_field("maxSteeringAngle", &self.m_maxSteeringAngle)?;
90 serializer
91 .serialize_field(
92 "maxSpeedFullSteeringAngle",
93 &self.m_maxSpeedFullSteeringAngle,
94 )?;
95 serializer
96 .serialize_array_field(
97 "doesWheelSteer",
98 &self.m_doesWheelSteer,
99 TypeSize::NonPtr,
100 )?;
101 serializer.end()
102 }
103 }
104};
105#[doc(hidden)]
106#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
107const _: () = {
108 use havok_serde as _serde;
109 #[automatically_derived]
110 impl<'de> _serde::Deserialize<'de> for hkpVehicleDefaultSteering {
111 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
112 where
113 __D: _serde::Deserializer<'de>,
114 {
115 #[allow(non_camel_case_types)]
116 enum __Field {
117 m_maxSteeringAngle,
118 m_maxSpeedFullSteeringAngle,
119 m_doesWheelSteer,
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 "maxSteeringAngle" => Ok(__Field::m_maxSteeringAngle),
144 "maxSpeedFullSteeringAngle" => {
145 Ok(__Field::m_maxSpeedFullSteeringAngle)
146 }
147 "doesWheelSteer" => Ok(__Field::m_doesWheelSteer),
148 _ => Ok(__Field::__ignore),
149 }
150 }
151 }
152 impl<'de> _serde::Deserialize<'de> for __Field {
153 #[inline]
154 fn deserialize<__D>(
155 __deserializer: __D,
156 ) -> core::result::Result<Self, __D::Error>
157 where
158 __D: _serde::Deserializer<'de>,
159 {
160 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
161 }
162 }
163 struct __hkpVehicleDefaultSteeringVisitor<'de> {
164 marker: _serde::__private::PhantomData<hkpVehicleDefaultSteering>,
165 lifetime: _serde::__private::PhantomData<&'de ()>,
166 }
167 #[allow(clippy::match_single_binding)]
168 #[allow(clippy::reversed_empty_ranges)]
169 #[allow(clippy::single_match)]
170 impl<'de> _serde::de::Visitor<'de>
171 for __hkpVehicleDefaultSteeringVisitor<'de> {
172 type Value = hkpVehicleDefaultSteering;
173 fn expecting(
174 &self,
175 __formatter: &mut core::fmt::Formatter,
176 ) -> core::fmt::Result {
177 core::fmt::Formatter::write_str(
178 __formatter,
179 "struct hkpVehicleDefaultSteering",
180 )
181 }
182 fn visit_struct_for_bytes<__A>(
183 self,
184 mut __map: __A,
185 ) -> _serde::__private::Result<Self::Value, __A::Error>
186 where
187 __A: _serde::de::MapAccess<'de>,
188 {
189 let __ptr = __A::class_ptr(&mut __map);
190 let parent = __A::parent_value(&mut __map)?;
191 let mut m_maxSteeringAngle: _serde::__private::Option<f32> = _serde::__private::None;
192 let mut m_maxSpeedFullSteeringAngle: _serde::__private::Option<
193 f32,
194 > = _serde::__private::None;
195 let mut m_doesWheelSteer: _serde::__private::Option<Vec<bool>> = _serde::__private::None;
196 for i in 0..3usize {
197 match i {
198 0usize => {
199 if _serde::__private::Option::is_some(&m_maxSteeringAngle) {
200 return _serde::__private::Err(
201 <__A::Error as _serde::de::Error>::duplicate_field(
202 "maxSteeringAngle",
203 ),
204 );
205 }
206 m_maxSteeringAngle = _serde::__private::Some(
207 match __A::next_value::<f32>(&mut __map) {
208 _serde::__private::Ok(__val) => __val,
209 _serde::__private::Err(__err) => {
210 return _serde::__private::Err(__err);
211 }
212 },
213 );
214 }
215 1usize => {
216 if _serde::__private::Option::is_some(
217 &m_maxSpeedFullSteeringAngle,
218 ) {
219 return _serde::__private::Err(
220 <__A::Error as _serde::de::Error>::duplicate_field(
221 "maxSpeedFullSteeringAngle",
222 ),
223 );
224 }
225 m_maxSpeedFullSteeringAngle = _serde::__private::Some(
226 match __A::next_value::<f32>(&mut __map) {
227 _serde::__private::Ok(__val) => __val,
228 _serde::__private::Err(__err) => {
229 return _serde::__private::Err(__err);
230 }
231 },
232 );
233 }
234 2usize => {
235 if _serde::__private::Option::is_some(&m_doesWheelSteer) {
236 return _serde::__private::Err(
237 <__A::Error as _serde::de::Error>::duplicate_field(
238 "doesWheelSteer",
239 ),
240 );
241 }
242 m_doesWheelSteer = _serde::__private::Some(
243 match __A::next_value::<Vec<bool>>(&mut __map) {
244 _serde::__private::Ok(__val) => __val,
245 _serde::__private::Err(__err) => {
246 return _serde::__private::Err(__err);
247 }
248 },
249 );
250 }
251 _ => {}
252 }
253 }
254 let m_maxSteeringAngle = match m_maxSteeringAngle {
255 _serde::__private::Some(__field) => __field,
256 _serde::__private::None => {
257 return _serde::__private::Err(
258 <__A::Error as _serde::de::Error>::missing_field(
259 "maxSteeringAngle",
260 ),
261 );
262 }
263 };
264 let m_maxSpeedFullSteeringAngle = match m_maxSpeedFullSteeringAngle {
265 _serde::__private::Some(__field) => __field,
266 _serde::__private::None => {
267 return _serde::__private::Err(
268 <__A::Error as _serde::de::Error>::missing_field(
269 "maxSpeedFullSteeringAngle",
270 ),
271 );
272 }
273 };
274 let m_doesWheelSteer = match m_doesWheelSteer {
275 _serde::__private::Some(__field) => __field,
276 _serde::__private::None => {
277 return _serde::__private::Err(
278 <__A::Error as _serde::de::Error>::missing_field(
279 "doesWheelSteer",
280 ),
281 );
282 }
283 };
284 _serde::__private::Ok(hkpVehicleDefaultSteering {
285 __ptr,
286 parent,
287 m_maxSteeringAngle,
288 m_maxSpeedFullSteeringAngle,
289 m_doesWheelSteer,
290 })
291 }
292 #[allow(clippy::manual_unwrap_or_default)]
293 fn visit_struct<__A>(
294 self,
295 mut __map: __A,
296 ) -> _serde::__private::Result<Self::Value, __A::Error>
297 where
298 __A: _serde::de::MapAccess<'de>,
299 {
300 let mut m_maxSteeringAngle: _serde::__private::Option<f32> = _serde::__private::None;
301 let mut m_maxSpeedFullSteeringAngle: _serde::__private::Option<
302 f32,
303 > = _serde::__private::None;
304 let mut m_doesWheelSteer: _serde::__private::Option<Vec<bool>> = _serde::__private::None;
305 while let _serde::__private::Some(__key) = {
306 __A::next_key::<__Field>(&mut __map)?
307 } {
308 match __key {
309 __Field::m_maxSteeringAngle => {
310 #[cfg(
311 any(feature = "strict", feature = "ignore_duplicates")
312 )]
313 if _serde::__private::Option::is_some(&m_maxSteeringAngle) {
314 #[cfg(feature = "ignore_duplicates")]
315 {
316 __A::skip_value(&mut __map)?;
317 continue;
318 }
319 #[cfg(feature = "strict")]
320 return _serde::__private::Err(
321 <__A::Error as _serde::de::Error>::duplicate_field(
322 "maxSteeringAngle",
323 ),
324 );
325 }
326 m_maxSteeringAngle = _serde::__private::Some(
327 match __A::next_value::<f32>(&mut __map) {
328 _serde::__private::Ok(__val) => __val,
329 _serde::__private::Err(__err) => {
330 return _serde::__private::Err(__err);
331 }
332 },
333 );
334 }
335 __Field::m_maxSpeedFullSteeringAngle => {
336 #[cfg(
337 any(feature = "strict", feature = "ignore_duplicates")
338 )]
339 if _serde::__private::Option::is_some(
340 &m_maxSpeedFullSteeringAngle,
341 ) {
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(
350 "maxSpeedFullSteeringAngle",
351 ),
352 );
353 }
354 m_maxSpeedFullSteeringAngle = _serde::__private::Some(
355 match __A::next_value::<f32>(&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_doesWheelSteer => {
364 #[cfg(
365 any(feature = "strict", feature = "ignore_duplicates")
366 )]
367 if _serde::__private::Option::is_some(&m_doesWheelSteer) {
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 "doesWheelSteer",
377 ),
378 );
379 }
380 m_doesWheelSteer = _serde::__private::Some(
381 match __A::next_value::<Vec<bool>>(&mut __map) {
382 _serde::__private::Ok(__val) => __val,
383 _serde::__private::Err(__err) => {
384 return _serde::__private::Err(__err);
385 }
386 },
387 );
388 }
389 _ => __A::skip_value(&mut __map)?,
390 }
391 }
392 let m_maxSteeringAngle = match m_maxSteeringAngle {
393 _serde::__private::Some(__field) => __field,
394 _serde::__private::None => {
395 #[cfg(feature = "strict")]
396 return _serde::__private::Err(
397 <__A::Error as _serde::de::Error>::missing_field(
398 "maxSteeringAngle",
399 ),
400 );
401 #[cfg(not(feature = "strict"))] Default::default()
402 }
403 };
404 let m_maxSpeedFullSteeringAngle = match m_maxSpeedFullSteeringAngle {
405 _serde::__private::Some(__field) => __field,
406 _serde::__private::None => {
407 #[cfg(feature = "strict")]
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::missing_field(
410 "maxSpeedFullSteeringAngle",
411 ),
412 );
413 #[cfg(not(feature = "strict"))] Default::default()
414 }
415 };
416 let m_doesWheelSteer = match m_doesWheelSteer {
417 _serde::__private::Some(__field) => __field,
418 _serde::__private::None => {
419 #[cfg(feature = "strict")]
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::missing_field(
422 "doesWheelSteer",
423 ),
424 );
425 #[cfg(not(feature = "strict"))] Default::default()
426 }
427 };
428 let __ptr = None;
429 let parent = hkBaseObject { __ptr };
430 let parent = hkReferencedObject {
431 __ptr,
432 parent,
433 ..Default::default()
434 };
435 let parent = hkpVehicleSteering {
436 __ptr,
437 parent,
438 };
439 let __ptr = __A::class_ptr(&mut __map);
440 _serde::__private::Ok(hkpVehicleDefaultSteering {
441 __ptr,
442 parent,
443 m_maxSteeringAngle,
444 m_maxSpeedFullSteeringAngle,
445 m_doesWheelSteer,
446 })
447 }
448 }
449 const FIELDS: &[&str] = &[
450 "maxSteeringAngle",
451 "maxSpeedFullSteeringAngle",
452 "doesWheelSteer",
453 ];
454 _serde::Deserializer::deserialize_struct(
455 deserializer,
456 "hkpVehicleDefaultSteering",
457 FIELDS,
458 __hkpVehicleDefaultSteeringVisitor {
459 marker: _serde::__private::PhantomData::<hkpVehicleDefaultSteering>,
460 lifetime: _serde::__private::PhantomData,
461 },
462 )
463 }
464 }
465};