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