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 hkpVehicleDefaultTransmission {
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: hkpVehicleTransmission,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "downshiftRPM"))]
35 #[cfg_attr(feature = "serde", serde(rename = "downshiftRPM"))]
36 pub m_downshiftRPM: f32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "upshiftRPM"))]
42 #[cfg_attr(feature = "serde", serde(rename = "upshiftRPM"))]
43 pub m_upshiftRPM: f32,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "primaryTransmissionRatio"))]
49 #[cfg_attr(feature = "serde", serde(rename = "primaryTransmissionRatio"))]
50 pub m_primaryTransmissionRatio: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "clutchDelayTime"))]
56 #[cfg_attr(feature = "serde", serde(rename = "clutchDelayTime"))]
57 pub m_clutchDelayTime: f32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "reverseGearRatio"))]
63 #[cfg_attr(feature = "serde", serde(rename = "reverseGearRatio"))]
64 pub m_reverseGearRatio: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "gearsRatio"))]
70 #[cfg_attr(feature = "serde", serde(rename = "gearsRatio"))]
71 pub m_gearsRatio: Vec<f32>,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "wheelsTorqueRatio"))]
77 #[cfg_attr(feature = "serde", serde(rename = "wheelsTorqueRatio"))]
78 pub m_wheelsTorqueRatio: Vec<f32>,
79}
80const _: () = {
81 use havok_serde as _serde;
82 impl _serde::HavokClass for hkpVehicleDefaultTransmission {
83 #[inline]
84 fn name(&self) -> &'static str {
85 "hkpVehicleDefaultTransmission"
86 }
87 #[inline]
88 fn signature(&self) -> _serde::__private::Signature {
89 _serde::__private::Signature::new(0x235d5d6b)
90 }
91 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
92 fn deps_indexes(&self) -> Vec<usize> {
93 let mut v = Vec::new();
94 v
95 }
96 }
97 impl _serde::Serialize for hkpVehicleDefaultTransmission {
98 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
99 where
100 S: _serde::ser::Serializer,
101 {
102 let class_meta = self
103 .__ptr
104 .map(|name| (name, _serde::__private::Signature::new(0x235d5d6b)));
105 let mut serializer = __serializer
106 .serialize_struct(
107 "hkpVehicleDefaultTransmission",
108 class_meta,
109 (52u64, 72u64),
110 )?;
111 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
112 serializer
113 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
114 serializer
115 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
116 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
117 serializer.serialize_field("downshiftRPM", &self.m_downshiftRPM)?;
118 serializer.serialize_field("upshiftRPM", &self.m_upshiftRPM)?;
119 serializer
120 .serialize_field(
121 "primaryTransmissionRatio",
122 &self.m_primaryTransmissionRatio,
123 )?;
124 serializer.serialize_field("clutchDelayTime", &self.m_clutchDelayTime)?;
125 serializer.serialize_field("reverseGearRatio", &self.m_reverseGearRatio)?;
126 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
127 serializer
128 .serialize_array_field(
129 "gearsRatio",
130 &self.m_gearsRatio,
131 TypeSize::NonPtr,
132 )?;
133 serializer
134 .serialize_array_field(
135 "wheelsTorqueRatio",
136 &self.m_wheelsTorqueRatio,
137 TypeSize::NonPtr,
138 )?;
139 serializer.end()
140 }
141 }
142};
143#[doc(hidden)]
144#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
145const _: () = {
146 use havok_serde as _serde;
147 #[automatically_derived]
148 impl<'de> _serde::Deserialize<'de> for hkpVehicleDefaultTransmission {
149 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
150 where
151 __D: _serde::Deserializer<'de>,
152 {
153 #[allow(non_camel_case_types)]
154 enum __Field {
155 m_downshiftRPM,
156 m_upshiftRPM,
157 m_primaryTransmissionRatio,
158 m_clutchDelayTime,
159 m_reverseGearRatio,
160 m_gearsRatio,
161 m_wheelsTorqueRatio,
162 __ignore,
163 }
164 struct __FieldVisitor;
165 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
166 type Value = __Field;
167 fn expecting(
168 &self,
169 __formatter: &mut core::fmt::Formatter,
170 ) -> core::fmt::Result {
171 core::fmt::Formatter::write_str(__formatter, "field identifier")
172 }
173 #[allow(clippy::match_single_binding)]
175 #[allow(clippy::reversed_empty_ranges)]
176 #[allow(clippy::single_match)]
177 fn visit_key<__E>(
178 self,
179 __value: &str,
180 ) -> core::result::Result<Self::Value, __E>
181 where
182 __E: _serde::de::Error,
183 {
184 match __value {
185 "downshiftRPM" => Ok(__Field::m_downshiftRPM),
186 "upshiftRPM" => Ok(__Field::m_upshiftRPM),
187 "primaryTransmissionRatio" => {
188 Ok(__Field::m_primaryTransmissionRatio)
189 }
190 "clutchDelayTime" => Ok(__Field::m_clutchDelayTime),
191 "reverseGearRatio" => Ok(__Field::m_reverseGearRatio),
192 "gearsRatio" => Ok(__Field::m_gearsRatio),
193 "wheelsTorqueRatio" => Ok(__Field::m_wheelsTorqueRatio),
194 _ => Ok(__Field::__ignore),
195 }
196 }
197 }
198 impl<'de> _serde::Deserialize<'de> for __Field {
199 #[inline]
200 fn deserialize<__D>(
201 __deserializer: __D,
202 ) -> core::result::Result<Self, __D::Error>
203 where
204 __D: _serde::Deserializer<'de>,
205 {
206 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
207 }
208 }
209 struct __hkpVehicleDefaultTransmissionVisitor<'de> {
210 marker: _serde::__private::PhantomData<hkpVehicleDefaultTransmission>,
211 lifetime: _serde::__private::PhantomData<&'de ()>,
212 }
213 #[allow(clippy::match_single_binding)]
214 #[allow(clippy::reversed_empty_ranges)]
215 #[allow(clippy::single_match)]
216 impl<'de> _serde::de::Visitor<'de>
217 for __hkpVehicleDefaultTransmissionVisitor<'de> {
218 type Value = hkpVehicleDefaultTransmission;
219 fn expecting(
220 &self,
221 __formatter: &mut core::fmt::Formatter,
222 ) -> core::fmt::Result {
223 core::fmt::Formatter::write_str(
224 __formatter,
225 "struct hkpVehicleDefaultTransmission",
226 )
227 }
228 fn visit_struct_for_bytes<__A>(
229 self,
230 mut __map: __A,
231 ) -> _serde::__private::Result<Self::Value, __A::Error>
232 where
233 __A: _serde::de::MapAccess<'de>,
234 {
235 let __ptr = __A::class_ptr(&mut __map);
236 let parent = __A::parent_value(&mut __map)?;
237 let mut m_downshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
238 let mut m_upshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
239 let mut m_primaryTransmissionRatio: _serde::__private::Option<f32> = _serde::__private::None;
240 let mut m_clutchDelayTime: _serde::__private::Option<f32> = _serde::__private::None;
241 let mut m_reverseGearRatio: _serde::__private::Option<f32> = _serde::__private::None;
242 let mut m_gearsRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
243 let mut m_wheelsTorqueRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
244 for i in 0..7usize {
245 match i {
246 0usize => {
247 if _serde::__private::Option::is_some(&m_downshiftRPM) {
248 return _serde::__private::Err(
249 <__A::Error as _serde::de::Error>::duplicate_field(
250 "downshiftRPM",
251 ),
252 );
253 }
254 m_downshiftRPM = _serde::__private::Some(
255 match __A::next_value::<f32>(&mut __map) {
256 _serde::__private::Ok(__val) => __val,
257 _serde::__private::Err(__err) => {
258 return _serde::__private::Err(__err);
259 }
260 },
261 );
262 }
263 1usize => {
264 if _serde::__private::Option::is_some(&m_upshiftRPM) {
265 return _serde::__private::Err(
266 <__A::Error as _serde::de::Error>::duplicate_field(
267 "upshiftRPM",
268 ),
269 );
270 }
271 m_upshiftRPM = _serde::__private::Some(
272 match __A::next_value::<f32>(&mut __map) {
273 _serde::__private::Ok(__val) => __val,
274 _serde::__private::Err(__err) => {
275 return _serde::__private::Err(__err);
276 }
277 },
278 );
279 }
280 2usize => {
281 if _serde::__private::Option::is_some(
282 &m_primaryTransmissionRatio,
283 ) {
284 return _serde::__private::Err(
285 <__A::Error as _serde::de::Error>::duplicate_field(
286 "primaryTransmissionRatio",
287 ),
288 );
289 }
290 m_primaryTransmissionRatio = _serde::__private::Some(
291 match __A::next_value::<f32>(&mut __map) {
292 _serde::__private::Ok(__val) => __val,
293 _serde::__private::Err(__err) => {
294 return _serde::__private::Err(__err);
295 }
296 },
297 );
298 }
299 3usize => {
300 if _serde::__private::Option::is_some(&m_clutchDelayTime) {
301 return _serde::__private::Err(
302 <__A::Error as _serde::de::Error>::duplicate_field(
303 "clutchDelayTime",
304 ),
305 );
306 }
307 m_clutchDelayTime = _serde::__private::Some(
308 match __A::next_value::<f32>(&mut __map) {
309 _serde::__private::Ok(__val) => __val,
310 _serde::__private::Err(__err) => {
311 return _serde::__private::Err(__err);
312 }
313 },
314 );
315 }
316 4usize => {
317 if _serde::__private::Option::is_some(&m_reverseGearRatio) {
318 return _serde::__private::Err(
319 <__A::Error as _serde::de::Error>::duplicate_field(
320 "reverseGearRatio",
321 ),
322 );
323 }
324 m_reverseGearRatio = _serde::__private::Some(
325 match __A::next_value::<f32>(&mut __map) {
326 _serde::__private::Ok(__val) => __val,
327 _serde::__private::Err(__err) => {
328 return _serde::__private::Err(__err);
329 }
330 },
331 );
332 }
333 5usize => {
334 if _serde::__private::Option::is_some(&m_gearsRatio) {
335 return _serde::__private::Err(
336 <__A::Error as _serde::de::Error>::duplicate_field(
337 "gearsRatio",
338 ),
339 );
340 }
341 __A::pad(&mut __map, 0usize, 4usize)?;
342 m_gearsRatio = _serde::__private::Some(
343 match __A::next_value::<Vec<f32>>(&mut __map) {
344 _serde::__private::Ok(__val) => __val,
345 _serde::__private::Err(__err) => {
346 return _serde::__private::Err(__err);
347 }
348 },
349 );
350 }
351 6usize => {
352 if _serde::__private::Option::is_some(
353 &m_wheelsTorqueRatio,
354 ) {
355 return _serde::__private::Err(
356 <__A::Error as _serde::de::Error>::duplicate_field(
357 "wheelsTorqueRatio",
358 ),
359 );
360 }
361 m_wheelsTorqueRatio = _serde::__private::Some(
362 match __A::next_value::<Vec<f32>>(&mut __map) {
363 _serde::__private::Ok(__val) => __val,
364 _serde::__private::Err(__err) => {
365 return _serde::__private::Err(__err);
366 }
367 },
368 );
369 }
370 _ => {}
371 }
372 }
373 let m_downshiftRPM = match m_downshiftRPM {
374 _serde::__private::Some(__field) => __field,
375 _serde::__private::None => {
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::missing_field(
378 "downshiftRPM",
379 ),
380 );
381 }
382 };
383 let m_upshiftRPM = match m_upshiftRPM {
384 _serde::__private::Some(__field) => __field,
385 _serde::__private::None => {
386 return _serde::__private::Err(
387 <__A::Error as _serde::de::Error>::missing_field(
388 "upshiftRPM",
389 ),
390 );
391 }
392 };
393 let m_primaryTransmissionRatio = match m_primaryTransmissionRatio {
394 _serde::__private::Some(__field) => __field,
395 _serde::__private::None => {
396 return _serde::__private::Err(
397 <__A::Error as _serde::de::Error>::missing_field(
398 "primaryTransmissionRatio",
399 ),
400 );
401 }
402 };
403 let m_clutchDelayTime = match m_clutchDelayTime {
404 _serde::__private::Some(__field) => __field,
405 _serde::__private::None => {
406 return _serde::__private::Err(
407 <__A::Error as _serde::de::Error>::missing_field(
408 "clutchDelayTime",
409 ),
410 );
411 }
412 };
413 let m_reverseGearRatio = match m_reverseGearRatio {
414 _serde::__private::Some(__field) => __field,
415 _serde::__private::None => {
416 return _serde::__private::Err(
417 <__A::Error as _serde::de::Error>::missing_field(
418 "reverseGearRatio",
419 ),
420 );
421 }
422 };
423 let m_gearsRatio = match m_gearsRatio {
424 _serde::__private::Some(__field) => __field,
425 _serde::__private::None => {
426 return _serde::__private::Err(
427 <__A::Error as _serde::de::Error>::missing_field(
428 "gearsRatio",
429 ),
430 );
431 }
432 };
433 let m_wheelsTorqueRatio = match m_wheelsTorqueRatio {
434 _serde::__private::Some(__field) => __field,
435 _serde::__private::None => {
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::missing_field(
438 "wheelsTorqueRatio",
439 ),
440 );
441 }
442 };
443 _serde::__private::Ok(hkpVehicleDefaultTransmission {
444 __ptr,
445 parent,
446 m_downshiftRPM,
447 m_upshiftRPM,
448 m_primaryTransmissionRatio,
449 m_clutchDelayTime,
450 m_reverseGearRatio,
451 m_gearsRatio,
452 m_wheelsTorqueRatio,
453 })
454 }
455 #[allow(clippy::manual_unwrap_or_default)]
456 fn visit_struct<__A>(
457 self,
458 mut __map: __A,
459 ) -> _serde::__private::Result<Self::Value, __A::Error>
460 where
461 __A: _serde::de::MapAccess<'de>,
462 {
463 let mut m_downshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
464 let mut m_upshiftRPM: _serde::__private::Option<f32> = _serde::__private::None;
465 let mut m_primaryTransmissionRatio: _serde::__private::Option<f32> = _serde::__private::None;
466 let mut m_clutchDelayTime: _serde::__private::Option<f32> = _serde::__private::None;
467 let mut m_reverseGearRatio: _serde::__private::Option<f32> = _serde::__private::None;
468 let mut m_gearsRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
469 let mut m_wheelsTorqueRatio: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
470 while let _serde::__private::Some(__key) = {
471 __A::next_key::<__Field>(&mut __map)?
472 } {
473 match __key {
474 __Field::m_downshiftRPM => {
475 #[cfg(
476 any(feature = "strict", feature = "ignore_duplicates")
477 )]
478 if _serde::__private::Option::is_some(&m_downshiftRPM) {
479 #[cfg(feature = "ignore_duplicates")]
480 {
481 __A::skip_value(&mut __map)?;
482 continue;
483 }
484 #[cfg(feature = "strict")]
485 return _serde::__private::Err(
486 <__A::Error as _serde::de::Error>::duplicate_field(
487 "downshiftRPM",
488 ),
489 );
490 }
491 m_downshiftRPM = _serde::__private::Some(
492 match __A::next_value::<f32>(&mut __map) {
493 _serde::__private::Ok(__val) => __val,
494 _serde::__private::Err(__err) => {
495 return _serde::__private::Err(__err);
496 }
497 },
498 );
499 }
500 __Field::m_upshiftRPM => {
501 #[cfg(
502 any(feature = "strict", feature = "ignore_duplicates")
503 )]
504 if _serde::__private::Option::is_some(&m_upshiftRPM) {
505 #[cfg(feature = "ignore_duplicates")]
506 {
507 __A::skip_value(&mut __map)?;
508 continue;
509 }
510 #[cfg(feature = "strict")]
511 return _serde::__private::Err(
512 <__A::Error as _serde::de::Error>::duplicate_field(
513 "upshiftRPM",
514 ),
515 );
516 }
517 m_upshiftRPM = _serde::__private::Some(
518 match __A::next_value::<f32>(&mut __map) {
519 _serde::__private::Ok(__val) => __val,
520 _serde::__private::Err(__err) => {
521 return _serde::__private::Err(__err);
522 }
523 },
524 );
525 }
526 __Field::m_primaryTransmissionRatio => {
527 #[cfg(
528 any(feature = "strict", feature = "ignore_duplicates")
529 )]
530 if _serde::__private::Option::is_some(
531 &m_primaryTransmissionRatio,
532 ) {
533 #[cfg(feature = "ignore_duplicates")]
534 {
535 __A::skip_value(&mut __map)?;
536 continue;
537 }
538 #[cfg(feature = "strict")]
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::duplicate_field(
541 "primaryTransmissionRatio",
542 ),
543 );
544 }
545 m_primaryTransmissionRatio = _serde::__private::Some(
546 match __A::next_value::<f32>(&mut __map) {
547 _serde::__private::Ok(__val) => __val,
548 _serde::__private::Err(__err) => {
549 return _serde::__private::Err(__err);
550 }
551 },
552 );
553 }
554 __Field::m_clutchDelayTime => {
555 #[cfg(
556 any(feature = "strict", feature = "ignore_duplicates")
557 )]
558 if _serde::__private::Option::is_some(&m_clutchDelayTime) {
559 #[cfg(feature = "ignore_duplicates")]
560 {
561 __A::skip_value(&mut __map)?;
562 continue;
563 }
564 #[cfg(feature = "strict")]
565 return _serde::__private::Err(
566 <__A::Error as _serde::de::Error>::duplicate_field(
567 "clutchDelayTime",
568 ),
569 );
570 }
571 m_clutchDelayTime = _serde::__private::Some(
572 match __A::next_value::<f32>(&mut __map) {
573 _serde::__private::Ok(__val) => __val,
574 _serde::__private::Err(__err) => {
575 return _serde::__private::Err(__err);
576 }
577 },
578 );
579 }
580 __Field::m_reverseGearRatio => {
581 #[cfg(
582 any(feature = "strict", feature = "ignore_duplicates")
583 )]
584 if _serde::__private::Option::is_some(&m_reverseGearRatio) {
585 #[cfg(feature = "ignore_duplicates")]
586 {
587 __A::skip_value(&mut __map)?;
588 continue;
589 }
590 #[cfg(feature = "strict")]
591 return _serde::__private::Err(
592 <__A::Error as _serde::de::Error>::duplicate_field(
593 "reverseGearRatio",
594 ),
595 );
596 }
597 m_reverseGearRatio = _serde::__private::Some(
598 match __A::next_value::<f32>(&mut __map) {
599 _serde::__private::Ok(__val) => __val,
600 _serde::__private::Err(__err) => {
601 return _serde::__private::Err(__err);
602 }
603 },
604 );
605 }
606 __Field::m_gearsRatio => {
607 #[cfg(
608 any(feature = "strict", feature = "ignore_duplicates")
609 )]
610 if _serde::__private::Option::is_some(&m_gearsRatio) {
611 #[cfg(feature = "ignore_duplicates")]
612 {
613 __A::skip_value(&mut __map)?;
614 continue;
615 }
616 #[cfg(feature = "strict")]
617 return _serde::__private::Err(
618 <__A::Error as _serde::de::Error>::duplicate_field(
619 "gearsRatio",
620 ),
621 );
622 }
623 m_gearsRatio = _serde::__private::Some(
624 match __A::next_value::<Vec<f32>>(&mut __map) {
625 _serde::__private::Ok(__val) => __val,
626 _serde::__private::Err(__err) => {
627 return _serde::__private::Err(__err);
628 }
629 },
630 );
631 }
632 __Field::m_wheelsTorqueRatio => {
633 #[cfg(
634 any(feature = "strict", feature = "ignore_duplicates")
635 )]
636 if _serde::__private::Option::is_some(
637 &m_wheelsTorqueRatio,
638 ) {
639 #[cfg(feature = "ignore_duplicates")]
640 {
641 __A::skip_value(&mut __map)?;
642 continue;
643 }
644 #[cfg(feature = "strict")]
645 return _serde::__private::Err(
646 <__A::Error as _serde::de::Error>::duplicate_field(
647 "wheelsTorqueRatio",
648 ),
649 );
650 }
651 m_wheelsTorqueRatio = _serde::__private::Some(
652 match __A::next_value::<Vec<f32>>(&mut __map) {
653 _serde::__private::Ok(__val) => __val,
654 _serde::__private::Err(__err) => {
655 return _serde::__private::Err(__err);
656 }
657 },
658 );
659 }
660 _ => __A::skip_value(&mut __map)?,
661 }
662 }
663 let m_downshiftRPM = match m_downshiftRPM {
664 _serde::__private::Some(__field) => __field,
665 _serde::__private::None => {
666 #[cfg(feature = "strict")]
667 return _serde::__private::Err(
668 <__A::Error as _serde::de::Error>::missing_field(
669 "downshiftRPM",
670 ),
671 );
672 #[cfg(not(feature = "strict"))] Default::default()
673 }
674 };
675 let m_upshiftRPM = match m_upshiftRPM {
676 _serde::__private::Some(__field) => __field,
677 _serde::__private::None => {
678 #[cfg(feature = "strict")]
679 return _serde::__private::Err(
680 <__A::Error as _serde::de::Error>::missing_field(
681 "upshiftRPM",
682 ),
683 );
684 #[cfg(not(feature = "strict"))] Default::default()
685 }
686 };
687 let m_primaryTransmissionRatio = match m_primaryTransmissionRatio {
688 _serde::__private::Some(__field) => __field,
689 _serde::__private::None => {
690 #[cfg(feature = "strict")]
691 return _serde::__private::Err(
692 <__A::Error as _serde::de::Error>::missing_field(
693 "primaryTransmissionRatio",
694 ),
695 );
696 #[cfg(not(feature = "strict"))] Default::default()
697 }
698 };
699 let m_clutchDelayTime = match m_clutchDelayTime {
700 _serde::__private::Some(__field) => __field,
701 _serde::__private::None => {
702 #[cfg(feature = "strict")]
703 return _serde::__private::Err(
704 <__A::Error as _serde::de::Error>::missing_field(
705 "clutchDelayTime",
706 ),
707 );
708 #[cfg(not(feature = "strict"))] Default::default()
709 }
710 };
711 let m_reverseGearRatio = match m_reverseGearRatio {
712 _serde::__private::Some(__field) => __field,
713 _serde::__private::None => {
714 #[cfg(feature = "strict")]
715 return _serde::__private::Err(
716 <__A::Error as _serde::de::Error>::missing_field(
717 "reverseGearRatio",
718 ),
719 );
720 #[cfg(not(feature = "strict"))] Default::default()
721 }
722 };
723 let m_gearsRatio = match m_gearsRatio {
724 _serde::__private::Some(__field) => __field,
725 _serde::__private::None => {
726 #[cfg(feature = "strict")]
727 return _serde::__private::Err(
728 <__A::Error as _serde::de::Error>::missing_field(
729 "gearsRatio",
730 ),
731 );
732 #[cfg(not(feature = "strict"))] Default::default()
733 }
734 };
735 let m_wheelsTorqueRatio = match m_wheelsTorqueRatio {
736 _serde::__private::Some(__field) => __field,
737 _serde::__private::None => {
738 #[cfg(feature = "strict")]
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::missing_field(
741 "wheelsTorqueRatio",
742 ),
743 );
744 #[cfg(not(feature = "strict"))] Default::default()
745 }
746 };
747 let __ptr = None;
748 let parent = hkBaseObject { __ptr };
749 let parent = hkReferencedObject {
750 __ptr,
751 parent,
752 ..Default::default()
753 };
754 let parent = hkpVehicleTransmission {
755 __ptr,
756 parent,
757 };
758 let __ptr = __A::class_ptr(&mut __map);
759 _serde::__private::Ok(hkpVehicleDefaultTransmission {
760 __ptr,
761 parent,
762 m_downshiftRPM,
763 m_upshiftRPM,
764 m_primaryTransmissionRatio,
765 m_clutchDelayTime,
766 m_reverseGearRatio,
767 m_gearsRatio,
768 m_wheelsTorqueRatio,
769 })
770 }
771 }
772 const FIELDS: &[&str] = &[
773 "downshiftRPM",
774 "upshiftRPM",
775 "primaryTransmissionRatio",
776 "clutchDelayTime",
777 "reverseGearRatio",
778 "gearsRatio",
779 "wheelsTorqueRatio",
780 ];
781 _serde::Deserializer::deserialize_struct(
782 deserializer,
783 "hkpVehicleDefaultTransmission",
784 FIELDS,
785 __hkpVehicleDefaultTransmissionVisitor {
786 marker: _serde::__private::PhantomData::<
787 hkpVehicleDefaultTransmission,
788 >,
789 lifetime: _serde::__private::PhantomData,
790 },
791 )
792 }
793 }
794};