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 hkpVehicleDefaultEngine {
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: hkpVehicleEngine,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "minRPM"))]
35 #[cfg_attr(feature = "serde", serde(rename = "minRPM"))]
36 pub m_minRPM: f32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "optRPM"))]
42 #[cfg_attr(feature = "serde", serde(rename = "optRPM"))]
43 pub m_optRPM: f32,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "maxRPM"))]
49 #[cfg_attr(feature = "serde", serde(rename = "maxRPM"))]
50 pub m_maxRPM: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "maxTorque"))]
56 #[cfg_attr(feature = "serde", serde(rename = "maxTorque"))]
57 pub m_maxTorque: f32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "torqueFactorAtMinRPM"))]
63 #[cfg_attr(feature = "serde", serde(rename = "torqueFactorAtMinRPM"))]
64 pub m_torqueFactorAtMinRPM: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "torqueFactorAtMaxRPM"))]
70 #[cfg_attr(feature = "serde", serde(rename = "torqueFactorAtMaxRPM"))]
71 pub m_torqueFactorAtMaxRPM: f32,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "resistanceFactorAtMinRPM"))]
77 #[cfg_attr(feature = "serde", serde(rename = "resistanceFactorAtMinRPM"))]
78 pub m_resistanceFactorAtMinRPM: f32,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "resistanceFactorAtOptRPM"))]
84 #[cfg_attr(feature = "serde", serde(rename = "resistanceFactorAtOptRPM"))]
85 pub m_resistanceFactorAtOptRPM: f32,
86 #[cfg_attr(feature = "json_schema", schemars(rename = "resistanceFactorAtMaxRPM"))]
91 #[cfg_attr(feature = "serde", serde(rename = "resistanceFactorAtMaxRPM"))]
92 pub m_resistanceFactorAtMaxRPM: f32,
93 #[cfg_attr(feature = "json_schema", schemars(rename = "clutchSlipRPM"))]
98 #[cfg_attr(feature = "serde", serde(rename = "clutchSlipRPM"))]
99 pub m_clutchSlipRPM: f32,
100}
101const _: () = {
102 use havok_serde as _serde;
103 impl _serde::HavokClass for hkpVehicleDefaultEngine {
104 #[inline]
105 fn name(&self) -> &'static str {
106 "hkpVehicleDefaultEngine"
107 }
108 #[inline]
109 fn signature(&self) -> _serde::__private::Signature {
110 _serde::__private::Signature::new(0x56f8ca24)
111 }
112 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
113 fn deps_indexes(&self) -> Vec<usize> {
114 let mut v = Vec::new();
115 v
116 }
117 }
118 impl _serde::Serialize for hkpVehicleDefaultEngine {
119 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
120 where
121 S: _serde::ser::Serializer,
122 {
123 let class_meta = self
124 .__ptr
125 .map(|name| (name, _serde::__private::Signature::new(0x56f8ca24)));
126 let mut serializer = __serializer
127 .serialize_struct(
128 "hkpVehicleDefaultEngine",
129 class_meta,
130 (48u64, 56u64),
131 )?;
132 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
133 serializer
134 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
135 serializer
136 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
137 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
138 serializer.serialize_field("minRPM", &self.m_minRPM)?;
139 serializer.serialize_field("optRPM", &self.m_optRPM)?;
140 serializer.serialize_field("maxRPM", &self.m_maxRPM)?;
141 serializer.serialize_field("maxTorque", &self.m_maxTorque)?;
142 serializer
143 .serialize_field("torqueFactorAtMinRPM", &self.m_torqueFactorAtMinRPM)?;
144 serializer
145 .serialize_field("torqueFactorAtMaxRPM", &self.m_torqueFactorAtMaxRPM)?;
146 serializer
147 .serialize_field(
148 "resistanceFactorAtMinRPM",
149 &self.m_resistanceFactorAtMinRPM,
150 )?;
151 serializer
152 .serialize_field(
153 "resistanceFactorAtOptRPM",
154 &self.m_resistanceFactorAtOptRPM,
155 )?;
156 serializer
157 .serialize_field(
158 "resistanceFactorAtMaxRPM",
159 &self.m_resistanceFactorAtMaxRPM,
160 )?;
161 serializer.serialize_field("clutchSlipRPM", &self.m_clutchSlipRPM)?;
162 serializer.end()
163 }
164 }
165};
166#[doc(hidden)]
167#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
168const _: () = {
169 use havok_serde as _serde;
170 #[automatically_derived]
171 impl<'de> _serde::Deserialize<'de> for hkpVehicleDefaultEngine {
172 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
173 where
174 __D: _serde::Deserializer<'de>,
175 {
176 #[allow(non_camel_case_types)]
177 enum __Field {
178 m_minRPM,
179 m_optRPM,
180 m_maxRPM,
181 m_maxTorque,
182 m_torqueFactorAtMinRPM,
183 m_torqueFactorAtMaxRPM,
184 m_resistanceFactorAtMinRPM,
185 m_resistanceFactorAtOptRPM,
186 m_resistanceFactorAtMaxRPM,
187 m_clutchSlipRPM,
188 __ignore,
189 }
190 struct __FieldVisitor;
191 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
192 type Value = __Field;
193 fn expecting(
194 &self,
195 __formatter: &mut core::fmt::Formatter,
196 ) -> core::fmt::Result {
197 core::fmt::Formatter::write_str(__formatter, "field identifier")
198 }
199 #[allow(clippy::match_single_binding)]
201 #[allow(clippy::reversed_empty_ranges)]
202 #[allow(clippy::single_match)]
203 fn visit_key<__E>(
204 self,
205 __value: &str,
206 ) -> core::result::Result<Self::Value, __E>
207 where
208 __E: _serde::de::Error,
209 {
210 match __value {
211 "minRPM" => Ok(__Field::m_minRPM),
212 "optRPM" => Ok(__Field::m_optRPM),
213 "maxRPM" => Ok(__Field::m_maxRPM),
214 "maxTorque" => Ok(__Field::m_maxTorque),
215 "torqueFactorAtMinRPM" => Ok(__Field::m_torqueFactorAtMinRPM),
216 "torqueFactorAtMaxRPM" => Ok(__Field::m_torqueFactorAtMaxRPM),
217 "resistanceFactorAtMinRPM" => {
218 Ok(__Field::m_resistanceFactorAtMinRPM)
219 }
220 "resistanceFactorAtOptRPM" => {
221 Ok(__Field::m_resistanceFactorAtOptRPM)
222 }
223 "resistanceFactorAtMaxRPM" => {
224 Ok(__Field::m_resistanceFactorAtMaxRPM)
225 }
226 "clutchSlipRPM" => Ok(__Field::m_clutchSlipRPM),
227 _ => Ok(__Field::__ignore),
228 }
229 }
230 }
231 impl<'de> _serde::Deserialize<'de> for __Field {
232 #[inline]
233 fn deserialize<__D>(
234 __deserializer: __D,
235 ) -> core::result::Result<Self, __D::Error>
236 where
237 __D: _serde::Deserializer<'de>,
238 {
239 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
240 }
241 }
242 struct __hkpVehicleDefaultEngineVisitor<'de> {
243 marker: _serde::__private::PhantomData<hkpVehicleDefaultEngine>,
244 lifetime: _serde::__private::PhantomData<&'de ()>,
245 }
246 #[allow(clippy::match_single_binding)]
247 #[allow(clippy::reversed_empty_ranges)]
248 #[allow(clippy::single_match)]
249 impl<'de> _serde::de::Visitor<'de>
250 for __hkpVehicleDefaultEngineVisitor<'de> {
251 type Value = hkpVehicleDefaultEngine;
252 fn expecting(
253 &self,
254 __formatter: &mut core::fmt::Formatter,
255 ) -> core::fmt::Result {
256 core::fmt::Formatter::write_str(
257 __formatter,
258 "struct hkpVehicleDefaultEngine",
259 )
260 }
261 fn visit_struct_for_bytes<__A>(
262 self,
263 mut __map: __A,
264 ) -> _serde::__private::Result<Self::Value, __A::Error>
265 where
266 __A: _serde::de::MapAccess<'de>,
267 {
268 let __ptr = __A::class_ptr(&mut __map);
269 let parent = __A::parent_value(&mut __map)?;
270 let mut m_minRPM: _serde::__private::Option<f32> = _serde::__private::None;
271 let mut m_optRPM: _serde::__private::Option<f32> = _serde::__private::None;
272 let mut m_maxRPM: _serde::__private::Option<f32> = _serde::__private::None;
273 let mut m_maxTorque: _serde::__private::Option<f32> = _serde::__private::None;
274 let mut m_torqueFactorAtMinRPM: _serde::__private::Option<f32> = _serde::__private::None;
275 let mut m_torqueFactorAtMaxRPM: _serde::__private::Option<f32> = _serde::__private::None;
276 let mut m_resistanceFactorAtMinRPM: _serde::__private::Option<f32> = _serde::__private::None;
277 let mut m_resistanceFactorAtOptRPM: _serde::__private::Option<f32> = _serde::__private::None;
278 let mut m_resistanceFactorAtMaxRPM: _serde::__private::Option<f32> = _serde::__private::None;
279 let mut m_clutchSlipRPM: _serde::__private::Option<f32> = _serde::__private::None;
280 for i in 0..10usize {
281 match i {
282 0usize => {
283 if _serde::__private::Option::is_some(&m_minRPM) {
284 return _serde::__private::Err(
285 <__A::Error as _serde::de::Error>::duplicate_field("minRPM"),
286 );
287 }
288 m_minRPM = _serde::__private::Some(
289 match __A::next_value::<f32>(&mut __map) {
290 _serde::__private::Ok(__val) => __val,
291 _serde::__private::Err(__err) => {
292 return _serde::__private::Err(__err);
293 }
294 },
295 );
296 }
297 1usize => {
298 if _serde::__private::Option::is_some(&m_optRPM) {
299 return _serde::__private::Err(
300 <__A::Error as _serde::de::Error>::duplicate_field("optRPM"),
301 );
302 }
303 m_optRPM = _serde::__private::Some(
304 match __A::next_value::<f32>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 2usize => {
313 if _serde::__private::Option::is_some(&m_maxRPM) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field("maxRPM"),
316 );
317 }
318 m_maxRPM = _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 3usize => {
328 if _serde::__private::Option::is_some(&m_maxTorque) {
329 return _serde::__private::Err(
330 <__A::Error as _serde::de::Error>::duplicate_field(
331 "maxTorque",
332 ),
333 );
334 }
335 m_maxTorque = _serde::__private::Some(
336 match __A::next_value::<f32>(&mut __map) {
337 _serde::__private::Ok(__val) => __val,
338 _serde::__private::Err(__err) => {
339 return _serde::__private::Err(__err);
340 }
341 },
342 );
343 }
344 4usize => {
345 if _serde::__private::Option::is_some(
346 &m_torqueFactorAtMinRPM,
347 ) {
348 return _serde::__private::Err(
349 <__A::Error as _serde::de::Error>::duplicate_field(
350 "torqueFactorAtMinRPM",
351 ),
352 );
353 }
354 m_torqueFactorAtMinRPM = _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 5usize => {
364 if _serde::__private::Option::is_some(
365 &m_torqueFactorAtMaxRPM,
366 ) {
367 return _serde::__private::Err(
368 <__A::Error as _serde::de::Error>::duplicate_field(
369 "torqueFactorAtMaxRPM",
370 ),
371 );
372 }
373 m_torqueFactorAtMaxRPM = _serde::__private::Some(
374 match __A::next_value::<f32>(&mut __map) {
375 _serde::__private::Ok(__val) => __val,
376 _serde::__private::Err(__err) => {
377 return _serde::__private::Err(__err);
378 }
379 },
380 );
381 }
382 6usize => {
383 if _serde::__private::Option::is_some(
384 &m_resistanceFactorAtMinRPM,
385 ) {
386 return _serde::__private::Err(
387 <__A::Error as _serde::de::Error>::duplicate_field(
388 "resistanceFactorAtMinRPM",
389 ),
390 );
391 }
392 m_resistanceFactorAtMinRPM = _serde::__private::Some(
393 match __A::next_value::<f32>(&mut __map) {
394 _serde::__private::Ok(__val) => __val,
395 _serde::__private::Err(__err) => {
396 return _serde::__private::Err(__err);
397 }
398 },
399 );
400 }
401 7usize => {
402 if _serde::__private::Option::is_some(
403 &m_resistanceFactorAtOptRPM,
404 ) {
405 return _serde::__private::Err(
406 <__A::Error as _serde::de::Error>::duplicate_field(
407 "resistanceFactorAtOptRPM",
408 ),
409 );
410 }
411 m_resistanceFactorAtOptRPM = _serde::__private::Some(
412 match __A::next_value::<f32>(&mut __map) {
413 _serde::__private::Ok(__val) => __val,
414 _serde::__private::Err(__err) => {
415 return _serde::__private::Err(__err);
416 }
417 },
418 );
419 }
420 8usize => {
421 if _serde::__private::Option::is_some(
422 &m_resistanceFactorAtMaxRPM,
423 ) {
424 return _serde::__private::Err(
425 <__A::Error as _serde::de::Error>::duplicate_field(
426 "resistanceFactorAtMaxRPM",
427 ),
428 );
429 }
430 m_resistanceFactorAtMaxRPM = _serde::__private::Some(
431 match __A::next_value::<f32>(&mut __map) {
432 _serde::__private::Ok(__val) => __val,
433 _serde::__private::Err(__err) => {
434 return _serde::__private::Err(__err);
435 }
436 },
437 );
438 }
439 9usize => {
440 if _serde::__private::Option::is_some(&m_clutchSlipRPM) {
441 return _serde::__private::Err(
442 <__A::Error as _serde::de::Error>::duplicate_field(
443 "clutchSlipRPM",
444 ),
445 );
446 }
447 m_clutchSlipRPM = _serde::__private::Some(
448 match __A::next_value::<f32>(&mut __map) {
449 _serde::__private::Ok(__val) => __val,
450 _serde::__private::Err(__err) => {
451 return _serde::__private::Err(__err);
452 }
453 },
454 );
455 }
456 _ => {}
457 }
458 }
459 let m_minRPM = match m_minRPM {
460 _serde::__private::Some(__field) => __field,
461 _serde::__private::None => {
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::missing_field("minRPM"),
464 );
465 }
466 };
467 let m_optRPM = match m_optRPM {
468 _serde::__private::Some(__field) => __field,
469 _serde::__private::None => {
470 return _serde::__private::Err(
471 <__A::Error as _serde::de::Error>::missing_field("optRPM"),
472 );
473 }
474 };
475 let m_maxRPM = match m_maxRPM {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::missing_field("maxRPM"),
480 );
481 }
482 };
483 let m_maxTorque = match m_maxTorque {
484 _serde::__private::Some(__field) => __field,
485 _serde::__private::None => {
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::missing_field(
488 "maxTorque",
489 ),
490 );
491 }
492 };
493 let m_torqueFactorAtMinRPM = match m_torqueFactorAtMinRPM {
494 _serde::__private::Some(__field) => __field,
495 _serde::__private::None => {
496 return _serde::__private::Err(
497 <__A::Error as _serde::de::Error>::missing_field(
498 "torqueFactorAtMinRPM",
499 ),
500 );
501 }
502 };
503 let m_torqueFactorAtMaxRPM = match m_torqueFactorAtMaxRPM {
504 _serde::__private::Some(__field) => __field,
505 _serde::__private::None => {
506 return _serde::__private::Err(
507 <__A::Error as _serde::de::Error>::missing_field(
508 "torqueFactorAtMaxRPM",
509 ),
510 );
511 }
512 };
513 let m_resistanceFactorAtMinRPM = match m_resistanceFactorAtMinRPM {
514 _serde::__private::Some(__field) => __field,
515 _serde::__private::None => {
516 return _serde::__private::Err(
517 <__A::Error as _serde::de::Error>::missing_field(
518 "resistanceFactorAtMinRPM",
519 ),
520 );
521 }
522 };
523 let m_resistanceFactorAtOptRPM = match m_resistanceFactorAtOptRPM {
524 _serde::__private::Some(__field) => __field,
525 _serde::__private::None => {
526 return _serde::__private::Err(
527 <__A::Error as _serde::de::Error>::missing_field(
528 "resistanceFactorAtOptRPM",
529 ),
530 );
531 }
532 };
533 let m_resistanceFactorAtMaxRPM = match m_resistanceFactorAtMaxRPM {
534 _serde::__private::Some(__field) => __field,
535 _serde::__private::None => {
536 return _serde::__private::Err(
537 <__A::Error as _serde::de::Error>::missing_field(
538 "resistanceFactorAtMaxRPM",
539 ),
540 );
541 }
542 };
543 let m_clutchSlipRPM = match m_clutchSlipRPM {
544 _serde::__private::Some(__field) => __field,
545 _serde::__private::None => {
546 return _serde::__private::Err(
547 <__A::Error as _serde::de::Error>::missing_field(
548 "clutchSlipRPM",
549 ),
550 );
551 }
552 };
553 _serde::__private::Ok(hkpVehicleDefaultEngine {
554 __ptr,
555 parent,
556 m_minRPM,
557 m_optRPM,
558 m_maxRPM,
559 m_maxTorque,
560 m_torqueFactorAtMinRPM,
561 m_torqueFactorAtMaxRPM,
562 m_resistanceFactorAtMinRPM,
563 m_resistanceFactorAtOptRPM,
564 m_resistanceFactorAtMaxRPM,
565 m_clutchSlipRPM,
566 })
567 }
568 #[allow(clippy::manual_unwrap_or_default)]
569 fn visit_struct<__A>(
570 self,
571 mut __map: __A,
572 ) -> _serde::__private::Result<Self::Value, __A::Error>
573 where
574 __A: _serde::de::MapAccess<'de>,
575 {
576 let mut m_minRPM: _serde::__private::Option<f32> = _serde::__private::None;
577 let mut m_optRPM: _serde::__private::Option<f32> = _serde::__private::None;
578 let mut m_maxRPM: _serde::__private::Option<f32> = _serde::__private::None;
579 let mut m_maxTorque: _serde::__private::Option<f32> = _serde::__private::None;
580 let mut m_torqueFactorAtMinRPM: _serde::__private::Option<f32> = _serde::__private::None;
581 let mut m_torqueFactorAtMaxRPM: _serde::__private::Option<f32> = _serde::__private::None;
582 let mut m_resistanceFactorAtMinRPM: _serde::__private::Option<f32> = _serde::__private::None;
583 let mut m_resistanceFactorAtOptRPM: _serde::__private::Option<f32> = _serde::__private::None;
584 let mut m_resistanceFactorAtMaxRPM: _serde::__private::Option<f32> = _serde::__private::None;
585 let mut m_clutchSlipRPM: _serde::__private::Option<f32> = _serde::__private::None;
586 while let _serde::__private::Some(__key) = {
587 __A::next_key::<__Field>(&mut __map)?
588 } {
589 match __key {
590 __Field::m_minRPM => {
591 #[cfg(
592 any(feature = "strict", feature = "ignore_duplicates")
593 )]
594 if _serde::__private::Option::is_some(&m_minRPM) {
595 #[cfg(feature = "ignore_duplicates")]
596 {
597 __A::skip_value(&mut __map)?;
598 continue;
599 }
600 #[cfg(feature = "strict")]
601 return _serde::__private::Err(
602 <__A::Error as _serde::de::Error>::duplicate_field("minRPM"),
603 );
604 }
605 m_minRPM = _serde::__private::Some(
606 match __A::next_value::<f32>(&mut __map) {
607 _serde::__private::Ok(__val) => __val,
608 _serde::__private::Err(__err) => {
609 return _serde::__private::Err(__err);
610 }
611 },
612 );
613 }
614 __Field::m_optRPM => {
615 #[cfg(
616 any(feature = "strict", feature = "ignore_duplicates")
617 )]
618 if _serde::__private::Option::is_some(&m_optRPM) {
619 #[cfg(feature = "ignore_duplicates")]
620 {
621 __A::skip_value(&mut __map)?;
622 continue;
623 }
624 #[cfg(feature = "strict")]
625 return _serde::__private::Err(
626 <__A::Error as _serde::de::Error>::duplicate_field("optRPM"),
627 );
628 }
629 m_optRPM = _serde::__private::Some(
630 match __A::next_value::<f32>(&mut __map) {
631 _serde::__private::Ok(__val) => __val,
632 _serde::__private::Err(__err) => {
633 return _serde::__private::Err(__err);
634 }
635 },
636 );
637 }
638 __Field::m_maxRPM => {
639 #[cfg(
640 any(feature = "strict", feature = "ignore_duplicates")
641 )]
642 if _serde::__private::Option::is_some(&m_maxRPM) {
643 #[cfg(feature = "ignore_duplicates")]
644 {
645 __A::skip_value(&mut __map)?;
646 continue;
647 }
648 #[cfg(feature = "strict")]
649 return _serde::__private::Err(
650 <__A::Error as _serde::de::Error>::duplicate_field("maxRPM"),
651 );
652 }
653 m_maxRPM = _serde::__private::Some(
654 match __A::next_value::<f32>(&mut __map) {
655 _serde::__private::Ok(__val) => __val,
656 _serde::__private::Err(__err) => {
657 return _serde::__private::Err(__err);
658 }
659 },
660 );
661 }
662 __Field::m_maxTorque => {
663 #[cfg(
664 any(feature = "strict", feature = "ignore_duplicates")
665 )]
666 if _serde::__private::Option::is_some(&m_maxTorque) {
667 #[cfg(feature = "ignore_duplicates")]
668 {
669 __A::skip_value(&mut __map)?;
670 continue;
671 }
672 #[cfg(feature = "strict")]
673 return _serde::__private::Err(
674 <__A::Error as _serde::de::Error>::duplicate_field(
675 "maxTorque",
676 ),
677 );
678 }
679 m_maxTorque = _serde::__private::Some(
680 match __A::next_value::<f32>(&mut __map) {
681 _serde::__private::Ok(__val) => __val,
682 _serde::__private::Err(__err) => {
683 return _serde::__private::Err(__err);
684 }
685 },
686 );
687 }
688 __Field::m_torqueFactorAtMinRPM => {
689 #[cfg(
690 any(feature = "strict", feature = "ignore_duplicates")
691 )]
692 if _serde::__private::Option::is_some(
693 &m_torqueFactorAtMinRPM,
694 ) {
695 #[cfg(feature = "ignore_duplicates")]
696 {
697 __A::skip_value(&mut __map)?;
698 continue;
699 }
700 #[cfg(feature = "strict")]
701 return _serde::__private::Err(
702 <__A::Error as _serde::de::Error>::duplicate_field(
703 "torqueFactorAtMinRPM",
704 ),
705 );
706 }
707 m_torqueFactorAtMinRPM = _serde::__private::Some(
708 match __A::next_value::<f32>(&mut __map) {
709 _serde::__private::Ok(__val) => __val,
710 _serde::__private::Err(__err) => {
711 return _serde::__private::Err(__err);
712 }
713 },
714 );
715 }
716 __Field::m_torqueFactorAtMaxRPM => {
717 #[cfg(
718 any(feature = "strict", feature = "ignore_duplicates")
719 )]
720 if _serde::__private::Option::is_some(
721 &m_torqueFactorAtMaxRPM,
722 ) {
723 #[cfg(feature = "ignore_duplicates")]
724 {
725 __A::skip_value(&mut __map)?;
726 continue;
727 }
728 #[cfg(feature = "strict")]
729 return _serde::__private::Err(
730 <__A::Error as _serde::de::Error>::duplicate_field(
731 "torqueFactorAtMaxRPM",
732 ),
733 );
734 }
735 m_torqueFactorAtMaxRPM = _serde::__private::Some(
736 match __A::next_value::<f32>(&mut __map) {
737 _serde::__private::Ok(__val) => __val,
738 _serde::__private::Err(__err) => {
739 return _serde::__private::Err(__err);
740 }
741 },
742 );
743 }
744 __Field::m_resistanceFactorAtMinRPM => {
745 #[cfg(
746 any(feature = "strict", feature = "ignore_duplicates")
747 )]
748 if _serde::__private::Option::is_some(
749 &m_resistanceFactorAtMinRPM,
750 ) {
751 #[cfg(feature = "ignore_duplicates")]
752 {
753 __A::skip_value(&mut __map)?;
754 continue;
755 }
756 #[cfg(feature = "strict")]
757 return _serde::__private::Err(
758 <__A::Error as _serde::de::Error>::duplicate_field(
759 "resistanceFactorAtMinRPM",
760 ),
761 );
762 }
763 m_resistanceFactorAtMinRPM = _serde::__private::Some(
764 match __A::next_value::<f32>(&mut __map) {
765 _serde::__private::Ok(__val) => __val,
766 _serde::__private::Err(__err) => {
767 return _serde::__private::Err(__err);
768 }
769 },
770 );
771 }
772 __Field::m_resistanceFactorAtOptRPM => {
773 #[cfg(
774 any(feature = "strict", feature = "ignore_duplicates")
775 )]
776 if _serde::__private::Option::is_some(
777 &m_resistanceFactorAtOptRPM,
778 ) {
779 #[cfg(feature = "ignore_duplicates")]
780 {
781 __A::skip_value(&mut __map)?;
782 continue;
783 }
784 #[cfg(feature = "strict")]
785 return _serde::__private::Err(
786 <__A::Error as _serde::de::Error>::duplicate_field(
787 "resistanceFactorAtOptRPM",
788 ),
789 );
790 }
791 m_resistanceFactorAtOptRPM = _serde::__private::Some(
792 match __A::next_value::<f32>(&mut __map) {
793 _serde::__private::Ok(__val) => __val,
794 _serde::__private::Err(__err) => {
795 return _serde::__private::Err(__err);
796 }
797 },
798 );
799 }
800 __Field::m_resistanceFactorAtMaxRPM => {
801 #[cfg(
802 any(feature = "strict", feature = "ignore_duplicates")
803 )]
804 if _serde::__private::Option::is_some(
805 &m_resistanceFactorAtMaxRPM,
806 ) {
807 #[cfg(feature = "ignore_duplicates")]
808 {
809 __A::skip_value(&mut __map)?;
810 continue;
811 }
812 #[cfg(feature = "strict")]
813 return _serde::__private::Err(
814 <__A::Error as _serde::de::Error>::duplicate_field(
815 "resistanceFactorAtMaxRPM",
816 ),
817 );
818 }
819 m_resistanceFactorAtMaxRPM = _serde::__private::Some(
820 match __A::next_value::<f32>(&mut __map) {
821 _serde::__private::Ok(__val) => __val,
822 _serde::__private::Err(__err) => {
823 return _serde::__private::Err(__err);
824 }
825 },
826 );
827 }
828 __Field::m_clutchSlipRPM => {
829 #[cfg(
830 any(feature = "strict", feature = "ignore_duplicates")
831 )]
832 if _serde::__private::Option::is_some(&m_clutchSlipRPM) {
833 #[cfg(feature = "ignore_duplicates")]
834 {
835 __A::skip_value(&mut __map)?;
836 continue;
837 }
838 #[cfg(feature = "strict")]
839 return _serde::__private::Err(
840 <__A::Error as _serde::de::Error>::duplicate_field(
841 "clutchSlipRPM",
842 ),
843 );
844 }
845 m_clutchSlipRPM = _serde::__private::Some(
846 match __A::next_value::<f32>(&mut __map) {
847 _serde::__private::Ok(__val) => __val,
848 _serde::__private::Err(__err) => {
849 return _serde::__private::Err(__err);
850 }
851 },
852 );
853 }
854 _ => __A::skip_value(&mut __map)?,
855 }
856 }
857 let m_minRPM = match m_minRPM {
858 _serde::__private::Some(__field) => __field,
859 _serde::__private::None => {
860 #[cfg(feature = "strict")]
861 return _serde::__private::Err(
862 <__A::Error as _serde::de::Error>::missing_field("minRPM"),
863 );
864 #[cfg(not(feature = "strict"))] Default::default()
865 }
866 };
867 let m_optRPM = match m_optRPM {
868 _serde::__private::Some(__field) => __field,
869 _serde::__private::None => {
870 #[cfg(feature = "strict")]
871 return _serde::__private::Err(
872 <__A::Error as _serde::de::Error>::missing_field("optRPM"),
873 );
874 #[cfg(not(feature = "strict"))] Default::default()
875 }
876 };
877 let m_maxRPM = match m_maxRPM {
878 _serde::__private::Some(__field) => __field,
879 _serde::__private::None => {
880 #[cfg(feature = "strict")]
881 return _serde::__private::Err(
882 <__A::Error as _serde::de::Error>::missing_field("maxRPM"),
883 );
884 #[cfg(not(feature = "strict"))] Default::default()
885 }
886 };
887 let m_maxTorque = match m_maxTorque {
888 _serde::__private::Some(__field) => __field,
889 _serde::__private::None => {
890 #[cfg(feature = "strict")]
891 return _serde::__private::Err(
892 <__A::Error as _serde::de::Error>::missing_field(
893 "maxTorque",
894 ),
895 );
896 #[cfg(not(feature = "strict"))] Default::default()
897 }
898 };
899 let m_torqueFactorAtMinRPM = match m_torqueFactorAtMinRPM {
900 _serde::__private::Some(__field) => __field,
901 _serde::__private::None => {
902 #[cfg(feature = "strict")]
903 return _serde::__private::Err(
904 <__A::Error as _serde::de::Error>::missing_field(
905 "torqueFactorAtMinRPM",
906 ),
907 );
908 #[cfg(not(feature = "strict"))] Default::default()
909 }
910 };
911 let m_torqueFactorAtMaxRPM = match m_torqueFactorAtMaxRPM {
912 _serde::__private::Some(__field) => __field,
913 _serde::__private::None => {
914 #[cfg(feature = "strict")]
915 return _serde::__private::Err(
916 <__A::Error as _serde::de::Error>::missing_field(
917 "torqueFactorAtMaxRPM",
918 ),
919 );
920 #[cfg(not(feature = "strict"))] Default::default()
921 }
922 };
923 let m_resistanceFactorAtMinRPM = match m_resistanceFactorAtMinRPM {
924 _serde::__private::Some(__field) => __field,
925 _serde::__private::None => {
926 #[cfg(feature = "strict")]
927 return _serde::__private::Err(
928 <__A::Error as _serde::de::Error>::missing_field(
929 "resistanceFactorAtMinRPM",
930 ),
931 );
932 #[cfg(not(feature = "strict"))] Default::default()
933 }
934 };
935 let m_resistanceFactorAtOptRPM = match m_resistanceFactorAtOptRPM {
936 _serde::__private::Some(__field) => __field,
937 _serde::__private::None => {
938 #[cfg(feature = "strict")]
939 return _serde::__private::Err(
940 <__A::Error as _serde::de::Error>::missing_field(
941 "resistanceFactorAtOptRPM",
942 ),
943 );
944 #[cfg(not(feature = "strict"))] Default::default()
945 }
946 };
947 let m_resistanceFactorAtMaxRPM = match m_resistanceFactorAtMaxRPM {
948 _serde::__private::Some(__field) => __field,
949 _serde::__private::None => {
950 #[cfg(feature = "strict")]
951 return _serde::__private::Err(
952 <__A::Error as _serde::de::Error>::missing_field(
953 "resistanceFactorAtMaxRPM",
954 ),
955 );
956 #[cfg(not(feature = "strict"))] Default::default()
957 }
958 };
959 let m_clutchSlipRPM = match m_clutchSlipRPM {
960 _serde::__private::Some(__field) => __field,
961 _serde::__private::None => {
962 #[cfg(feature = "strict")]
963 return _serde::__private::Err(
964 <__A::Error as _serde::de::Error>::missing_field(
965 "clutchSlipRPM",
966 ),
967 );
968 #[cfg(not(feature = "strict"))] Default::default()
969 }
970 };
971 let __ptr = None;
972 let parent = hkBaseObject { __ptr };
973 let parent = hkReferencedObject {
974 __ptr,
975 parent,
976 ..Default::default()
977 };
978 let parent = hkpVehicleEngine { __ptr, parent };
979 let __ptr = __A::class_ptr(&mut __map);
980 _serde::__private::Ok(hkpVehicleDefaultEngine {
981 __ptr,
982 parent,
983 m_minRPM,
984 m_optRPM,
985 m_maxRPM,
986 m_maxTorque,
987 m_torqueFactorAtMinRPM,
988 m_torqueFactorAtMaxRPM,
989 m_resistanceFactorAtMinRPM,
990 m_resistanceFactorAtOptRPM,
991 m_resistanceFactorAtMaxRPM,
992 m_clutchSlipRPM,
993 })
994 }
995 }
996 const FIELDS: &[&str] = &[
997 "minRPM",
998 "optRPM",
999 "maxRPM",
1000 "maxTorque",
1001 "torqueFactorAtMinRPM",
1002 "torqueFactorAtMaxRPM",
1003 "resistanceFactorAtMinRPM",
1004 "resistanceFactorAtOptRPM",
1005 "resistanceFactorAtMaxRPM",
1006 "clutchSlipRPM",
1007 ];
1008 _serde::Deserializer::deserialize_struct(
1009 deserializer,
1010 "hkpVehicleDefaultEngine",
1011 FIELDS,
1012 __hkpVehicleDefaultEngineVisitor {
1013 marker: _serde::__private::PhantomData::<hkpVehicleDefaultEngine>,
1014 lifetime: _serde::__private::PhantomData,
1015 },
1016 )
1017 }
1018 }
1019};