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