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