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 hkpMotorAction<'a> {
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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkpUnaryAction<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "axis"))]
36 #[cfg_attr(feature = "serde", serde(rename = "axis"))]
37 pub m_axis: Vector4,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "spinRate"))]
43 #[cfg_attr(feature = "serde", serde(rename = "spinRate"))]
44 pub m_spinRate: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "gain"))]
50 #[cfg_attr(feature = "serde", serde(rename = "gain"))]
51 pub m_gain: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "active"))]
57 #[cfg_attr(feature = "serde", serde(rename = "active"))]
58 pub m_active: bool,
59}
60const _: () = {
61 use havok_serde as _serde;
62 impl<'a> _serde::HavokClass for hkpMotorAction<'a> {
63 #[inline]
64 fn name(&self) -> &'static str {
65 "hkpMotorAction"
66 }
67 #[inline]
68 fn signature(&self) -> _serde::__private::Signature {
69 _serde::__private::Signature::new(0x8ff131d9)
70 }
71 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
72 fn deps_indexes(&self) -> Vec<usize> {
73 let mut v = Vec::new();
74 v.push(self.parent.parent.m_world.get());
75 v.push(self.parent.parent.m_island.get());
76 v.push(self.parent.m_entity.get());
77 v
78 }
79 }
80 impl<'a> _serde::Serialize for hkpMotorAction<'a> {
81 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
82 where
83 S: _serde::ser::Serializer,
84 {
85 let class_meta = self
86 .__ptr
87 .map(|name| (name, _serde::__private::Signature::new(0x8ff131d9)));
88 let mut serializer = __serializer
89 .serialize_struct("hkpMotorAction", class_meta, (64u64, 96u64))?;
90 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
91 serializer
92 .skip_field(
93 "memSizeAndFlags",
94 &self.parent.parent.parent.m_memSizeAndFlags,
95 )?;
96 serializer
97 .skip_field(
98 "referenceCount",
99 &self.parent.parent.parent.m_referenceCount,
100 )?;
101 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
102 serializer.skip_field("world", &self.parent.parent.m_world)?;
103 serializer.skip_field("island", &self.parent.parent.m_island)?;
104 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
105 serializer.serialize_field("name", &self.parent.parent.m_name)?;
106 serializer.serialize_field("entity", &self.parent.m_entity)?;
107 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
108 serializer.serialize_field("axis", &self.m_axis)?;
109 serializer.serialize_field("spinRate", &self.m_spinRate)?;
110 serializer.serialize_field("gain", &self.m_gain)?;
111 serializer.serialize_field("active", &self.m_active)?;
112 serializer.pad_field([0u8; 7usize].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 hkpMotorAction<'de> {
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_userData,
130 m_name,
131 m_entity,
132 m_axis,
133 m_spinRate,
134 m_gain,
135 m_active,
136 __ignore,
137 }
138 struct __FieldVisitor;
139 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
140 type Value = __Field;
141 fn expecting(
142 &self,
143 __formatter: &mut core::fmt::Formatter,
144 ) -> core::fmt::Result {
145 core::fmt::Formatter::write_str(__formatter, "field identifier")
146 }
147 #[allow(clippy::match_single_binding)]
149 #[allow(clippy::reversed_empty_ranges)]
150 #[allow(clippy::single_match)]
151 fn visit_key<__E>(
152 self,
153 __value: &str,
154 ) -> core::result::Result<Self::Value, __E>
155 where
156 __E: _serde::de::Error,
157 {
158 match __value {
159 "userData" => Ok(__Field::m_userData),
160 "name" => Ok(__Field::m_name),
161 "entity" => Ok(__Field::m_entity),
162 "axis" => Ok(__Field::m_axis),
163 "spinRate" => Ok(__Field::m_spinRate),
164 "gain" => Ok(__Field::m_gain),
165 "active" => Ok(__Field::m_active),
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 __hkpMotorActionVisitor<'de> {
182 marker: _serde::__private::PhantomData<hkpMotorAction<'de>>,
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> for __hkpMotorActionVisitor<'de> {
189 type Value = hkpMotorAction<'de>;
190 fn expecting(
191 &self,
192 __formatter: &mut core::fmt::Formatter,
193 ) -> core::fmt::Result {
194 core::fmt::Formatter::write_str(__formatter, "struct hkpMotorAction")
195 }
196 fn visit_struct_for_bytes<__A>(
197 self,
198 mut __map: __A,
199 ) -> _serde::__private::Result<Self::Value, __A::Error>
200 where
201 __A: _serde::de::MapAccess<'de>,
202 {
203 let __ptr = __A::class_ptr(&mut __map);
204 let parent = __A::parent_value(&mut __map)?;
205 let mut m_axis: _serde::__private::Option<Vector4> = _serde::__private::None;
206 let mut m_spinRate: _serde::__private::Option<f32> = _serde::__private::None;
207 let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
208 let mut m_active: _serde::__private::Option<bool> = _serde::__private::None;
209 for i in 0..4usize {
210 match i {
211 0usize => {
212 if _serde::__private::Option::is_some(&m_axis) {
213 return _serde::__private::Err(
214 <__A::Error as _serde::de::Error>::duplicate_field("axis"),
215 );
216 }
217 __A::pad(&mut __map, 4usize, 8usize)?;
218 m_axis = _serde::__private::Some(
219 match __A::next_value::<Vector4>(&mut __map) {
220 _serde::__private::Ok(__val) => __val,
221 _serde::__private::Err(__err) => {
222 return _serde::__private::Err(__err);
223 }
224 },
225 );
226 }
227 1usize => {
228 if _serde::__private::Option::is_some(&m_spinRate) {
229 return _serde::__private::Err(
230 <__A::Error as _serde::de::Error>::duplicate_field(
231 "spinRate",
232 ),
233 );
234 }
235 m_spinRate = _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 2usize => {
245 if _serde::__private::Option::is_some(&m_gain) {
246 return _serde::__private::Err(
247 <__A::Error as _serde::de::Error>::duplicate_field("gain"),
248 );
249 }
250 m_gain = _serde::__private::Some(
251 match __A::next_value::<f32>(&mut __map) {
252 _serde::__private::Ok(__val) => __val,
253 _serde::__private::Err(__err) => {
254 return _serde::__private::Err(__err);
255 }
256 },
257 );
258 }
259 3usize => {
260 if _serde::__private::Option::is_some(&m_active) {
261 return _serde::__private::Err(
262 <__A::Error as _serde::de::Error>::duplicate_field("active"),
263 );
264 }
265 m_active = _serde::__private::Some(
266 match __A::next_value::<bool>(&mut __map) {
267 _serde::__private::Ok(__val) => __val,
268 _serde::__private::Err(__err) => {
269 return _serde::__private::Err(__err);
270 }
271 },
272 );
273 }
274 _ => {}
275 }
276 }
277 __A::pad(&mut __map, 7usize, 7usize)?;
278 let m_axis = match m_axis {
279 _serde::__private::Some(__field) => __field,
280 _serde::__private::None => {
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::missing_field("axis"),
283 );
284 }
285 };
286 let m_spinRate = match m_spinRate {
287 _serde::__private::Some(__field) => __field,
288 _serde::__private::None => {
289 return _serde::__private::Err(
290 <__A::Error as _serde::de::Error>::missing_field("spinRate"),
291 );
292 }
293 };
294 let m_gain = match m_gain {
295 _serde::__private::Some(__field) => __field,
296 _serde::__private::None => {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::missing_field("gain"),
299 );
300 }
301 };
302 let m_active = match m_active {
303 _serde::__private::Some(__field) => __field,
304 _serde::__private::None => {
305 return _serde::__private::Err(
306 <__A::Error as _serde::de::Error>::missing_field("active"),
307 );
308 }
309 };
310 _serde::__private::Ok(hkpMotorAction {
311 __ptr,
312 parent,
313 m_axis,
314 m_spinRate,
315 m_gain,
316 m_active,
317 })
318 }
319 #[allow(clippy::manual_unwrap_or_default)]
320 fn visit_struct<__A>(
321 self,
322 mut __map: __A,
323 ) -> _serde::__private::Result<Self::Value, __A::Error>
324 where
325 __A: _serde::de::MapAccess<'de>,
326 {
327 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
328 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
329 let mut m_entity: _serde::__private::Option<Pointer> = _serde::__private::None;
330 let mut m_axis: _serde::__private::Option<Vector4> = _serde::__private::None;
331 let mut m_spinRate: _serde::__private::Option<f32> = _serde::__private::None;
332 let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
333 let mut m_active: _serde::__private::Option<bool> = _serde::__private::None;
334 while let _serde::__private::Some(__key) = {
335 __A::next_key::<__Field>(&mut __map)?
336 } {
337 match __key {
338 __Field::m_userData => {
339 #[cfg(
340 any(feature = "strict", feature = "ignore_duplicates")
341 )]
342 if _serde::__private::Option::is_some(&m_userData) {
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 "userData",
352 ),
353 );
354 }
355 m_userData = _serde::__private::Some(
356 match __A::next_value::<Ulong>(&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_name => {
365 #[cfg(
366 any(feature = "strict", feature = "ignore_duplicates")
367 )]
368 if _serde::__private::Option::is_some(&m_name) {
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("name"),
377 );
378 }
379 m_name = _serde::__private::Some(
380 match __A::next_value::<StringPtr<'de>>(&mut __map) {
381 _serde::__private::Ok(__val) => __val,
382 _serde::__private::Err(__err) => {
383 return _serde::__private::Err(__err);
384 }
385 },
386 );
387 }
388 __Field::m_entity => {
389 #[cfg(
390 any(feature = "strict", feature = "ignore_duplicates")
391 )]
392 if _serde::__private::Option::is_some(&m_entity) {
393 #[cfg(feature = "ignore_duplicates")]
394 {
395 __A::skip_value(&mut __map)?;
396 continue;
397 }
398 #[cfg(feature = "strict")]
399 return _serde::__private::Err(
400 <__A::Error as _serde::de::Error>::duplicate_field("entity"),
401 );
402 }
403 m_entity = _serde::__private::Some(
404 match __A::next_value::<Pointer>(&mut __map) {
405 _serde::__private::Ok(__val) => __val,
406 _serde::__private::Err(__err) => {
407 return _serde::__private::Err(__err);
408 }
409 },
410 );
411 }
412 __Field::m_axis => {
413 #[cfg(
414 any(feature = "strict", feature = "ignore_duplicates")
415 )]
416 if _serde::__private::Option::is_some(&m_axis) {
417 #[cfg(feature = "ignore_duplicates")]
418 {
419 __A::skip_value(&mut __map)?;
420 continue;
421 }
422 #[cfg(feature = "strict")]
423 return _serde::__private::Err(
424 <__A::Error as _serde::de::Error>::duplicate_field("axis"),
425 );
426 }
427 m_axis = _serde::__private::Some(
428 match __A::next_value::<Vector4>(&mut __map) {
429 _serde::__private::Ok(__val) => __val,
430 _serde::__private::Err(__err) => {
431 return _serde::__private::Err(__err);
432 }
433 },
434 );
435 }
436 __Field::m_spinRate => {
437 #[cfg(
438 any(feature = "strict", feature = "ignore_duplicates")
439 )]
440 if _serde::__private::Option::is_some(&m_spinRate) {
441 #[cfg(feature = "ignore_duplicates")]
442 {
443 __A::skip_value(&mut __map)?;
444 continue;
445 }
446 #[cfg(feature = "strict")]
447 return _serde::__private::Err(
448 <__A::Error as _serde::de::Error>::duplicate_field(
449 "spinRate",
450 ),
451 );
452 }
453 m_spinRate = _serde::__private::Some(
454 match __A::next_value::<f32>(&mut __map) {
455 _serde::__private::Ok(__val) => __val,
456 _serde::__private::Err(__err) => {
457 return _serde::__private::Err(__err);
458 }
459 },
460 );
461 }
462 __Field::m_gain => {
463 #[cfg(
464 any(feature = "strict", feature = "ignore_duplicates")
465 )]
466 if _serde::__private::Option::is_some(&m_gain) {
467 #[cfg(feature = "ignore_duplicates")]
468 {
469 __A::skip_value(&mut __map)?;
470 continue;
471 }
472 #[cfg(feature = "strict")]
473 return _serde::__private::Err(
474 <__A::Error as _serde::de::Error>::duplicate_field("gain"),
475 );
476 }
477 m_gain = _serde::__private::Some(
478 match __A::next_value::<f32>(&mut __map) {
479 _serde::__private::Ok(__val) => __val,
480 _serde::__private::Err(__err) => {
481 return _serde::__private::Err(__err);
482 }
483 },
484 );
485 }
486 __Field::m_active => {
487 #[cfg(
488 any(feature = "strict", feature = "ignore_duplicates")
489 )]
490 if _serde::__private::Option::is_some(&m_active) {
491 #[cfg(feature = "ignore_duplicates")]
492 {
493 __A::skip_value(&mut __map)?;
494 continue;
495 }
496 #[cfg(feature = "strict")]
497 return _serde::__private::Err(
498 <__A::Error as _serde::de::Error>::duplicate_field("active"),
499 );
500 }
501 m_active = _serde::__private::Some(
502 match __A::next_value::<bool>(&mut __map) {
503 _serde::__private::Ok(__val) => __val,
504 _serde::__private::Err(__err) => {
505 return _serde::__private::Err(__err);
506 }
507 },
508 );
509 }
510 _ => __A::skip_value(&mut __map)?,
511 }
512 }
513 let m_userData = match m_userData {
514 _serde::__private::Some(__field) => __field,
515 _serde::__private::None => {
516 #[cfg(feature = "strict")]
517 return _serde::__private::Err(
518 <__A::Error as _serde::de::Error>::missing_field("userData"),
519 );
520 #[cfg(not(feature = "strict"))] Default::default()
521 }
522 };
523 let m_name = match m_name {
524 _serde::__private::Some(__field) => __field,
525 _serde::__private::None => {
526 #[cfg(feature = "strict")]
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field("name"),
529 );
530 #[cfg(not(feature = "strict"))] Default::default()
531 }
532 };
533 let m_entity = match m_entity {
534 _serde::__private::Some(__field) => __field,
535 _serde::__private::None => {
536 #[cfg(feature = "strict")]
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::missing_field("entity"),
539 );
540 #[cfg(not(feature = "strict"))] Default::default()
541 }
542 };
543 let m_axis = match m_axis {
544 _serde::__private::Some(__field) => __field,
545 _serde::__private::None => {
546 #[cfg(feature = "strict")]
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::missing_field("axis"),
549 );
550 #[cfg(not(feature = "strict"))] Default::default()
551 }
552 };
553 let m_spinRate = match m_spinRate {
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("spinRate"),
559 );
560 #[cfg(not(feature = "strict"))] Default::default()
561 }
562 };
563 let m_gain = match m_gain {
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("gain"),
569 );
570 #[cfg(not(feature = "strict"))] Default::default()
571 }
572 };
573 let m_active = match m_active {
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("active"),
579 );
580 #[cfg(not(feature = "strict"))] Default::default()
581 }
582 };
583 let __ptr = None;
584 let parent = hkBaseObject { __ptr };
585 let parent = hkReferencedObject {
586 __ptr,
587 parent,
588 ..Default::default()
589 };
590 let parent = hkpAction {
591 __ptr,
592 parent,
593 m_userData,
594 m_name,
595 ..Default::default()
596 };
597 let parent = hkpUnaryAction {
598 __ptr,
599 parent,
600 m_entity,
601 };
602 let __ptr = __A::class_ptr(&mut __map);
603 _serde::__private::Ok(hkpMotorAction {
604 __ptr,
605 parent,
606 m_axis,
607 m_spinRate,
608 m_gain,
609 m_active,
610 })
611 }
612 }
613 const FIELDS: &[&str] = &["axis", "spinRate", "gain", "active"];
614 _serde::Deserializer::deserialize_struct(
615 deserializer,
616 "hkpMotorAction",
617 FIELDS,
618 __hkpMotorActionVisitor {
619 marker: _serde::__private::PhantomData::<hkpMotorAction>,
620 lifetime: _serde::__private::PhantomData,
621 },
622 )
623 }
624 }
625};