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