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