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 hkbHandIkControlData {
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(rename = "targetPosition"))]
31 #[cfg_attr(feature = "serde", serde(rename = "targetPosition"))]
32 pub m_targetPosition: Vector4,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "targetRotation"))]
38 #[cfg_attr(feature = "serde", serde(rename = "targetRotation"))]
39 pub m_targetRotation: Quaternion,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "targetNormal"))]
45 #[cfg_attr(feature = "serde", serde(rename = "targetNormal"))]
46 pub m_targetNormal: Vector4,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "targetHandle"))]
52 #[cfg_attr(feature = "serde", serde(rename = "targetHandle"))]
53 pub m_targetHandle: Pointer,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "transformOnFraction"))]
59 #[cfg_attr(feature = "serde", serde(rename = "transformOnFraction"))]
60 pub m_transformOnFraction: f32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "normalOnFraction"))]
66 #[cfg_attr(feature = "serde", serde(rename = "normalOnFraction"))]
67 pub m_normalOnFraction: f32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "fadeInDuration"))]
73 #[cfg_attr(feature = "serde", serde(rename = "fadeInDuration"))]
74 pub m_fadeInDuration: f32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "fadeOutDuration"))]
80 #[cfg_attr(feature = "serde", serde(rename = "fadeOutDuration"))]
81 pub m_fadeOutDuration: f32,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "extrapolationTimeStep"))]
87 #[cfg_attr(feature = "serde", serde(rename = "extrapolationTimeStep"))]
88 pub m_extrapolationTimeStep: f32,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "handleChangeSpeed"))]
94 #[cfg_attr(feature = "serde", serde(rename = "handleChangeSpeed"))]
95 pub m_handleChangeSpeed: f32,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "handleChangeMode"))]
101 #[cfg_attr(feature = "serde", serde(rename = "handleChangeMode"))]
102 pub m_handleChangeMode: HandleChangeMode,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "fixUp"))]
108 #[cfg_attr(feature = "serde", serde(rename = "fixUp"))]
109 pub m_fixUp: bool,
110}
111const _: () = {
112 use havok_serde as _serde;
113 impl _serde::HavokClass for hkbHandIkControlData {
114 #[inline]
115 fn name(&self) -> &'static str {
116 "hkbHandIkControlData"
117 }
118 #[inline]
119 fn signature(&self) -> _serde::__private::Signature {
120 _serde::__private::Signature::new(0xd72b8d17)
121 }
122 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
123 fn deps_indexes(&self) -> Vec<usize> {
124 let mut v = Vec::new();
125 v.push(self.m_targetHandle.get());
126 v
127 }
128 }
129 impl _serde::Serialize for hkbHandIkControlData {
130 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
131 where
132 S: _serde::ser::Serializer,
133 {
134 let class_meta = self
135 .__ptr
136 .map(|name| (name, _serde::__private::Signature::new(0xd72b8d17)));
137 let mut serializer = __serializer
138 .serialize_struct("hkbHandIkControlData", class_meta, (80u64, 96u64))?;
139 serializer.serialize_field("targetPosition", &self.m_targetPosition)?;
140 serializer.serialize_field("targetRotation", &self.m_targetRotation)?;
141 serializer.serialize_field("targetNormal", &self.m_targetNormal)?;
142 serializer.serialize_field("targetHandle", &self.m_targetHandle)?;
143 serializer
144 .serialize_field("transformOnFraction", &self.m_transformOnFraction)?;
145 serializer.serialize_field("normalOnFraction", &self.m_normalOnFraction)?;
146 serializer.serialize_field("fadeInDuration", &self.m_fadeInDuration)?;
147 serializer.serialize_field("fadeOutDuration", &self.m_fadeOutDuration)?;
148 serializer
149 .serialize_field(
150 "extrapolationTimeStep",
151 &self.m_extrapolationTimeStep,
152 )?;
153 serializer.serialize_field("handleChangeSpeed", &self.m_handleChangeSpeed)?;
154 serializer.serialize_field("handleChangeMode", &self.m_handleChangeMode)?;
155 serializer.serialize_field("fixUp", &self.m_fixUp)?;
156 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 14usize].as_slice())?;
157 serializer.end()
158 }
159 }
160};
161#[doc(hidden)]
162#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
163const _: () = {
164 use havok_serde as _serde;
165 #[automatically_derived]
166 impl<'de> _serde::Deserialize<'de> for hkbHandIkControlData {
167 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
168 where
169 __D: _serde::Deserializer<'de>,
170 {
171 #[allow(non_camel_case_types)]
172 enum __Field {
173 m_targetPosition,
174 m_targetRotation,
175 m_targetNormal,
176 m_targetHandle,
177 m_transformOnFraction,
178 m_normalOnFraction,
179 m_fadeInDuration,
180 m_fadeOutDuration,
181 m_extrapolationTimeStep,
182 m_handleChangeSpeed,
183 m_handleChangeMode,
184 m_fixUp,
185 __ignore,
186 }
187 struct __FieldVisitor;
188 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
189 type Value = __Field;
190 fn expecting(
191 &self,
192 __formatter: &mut core::fmt::Formatter,
193 ) -> core::fmt::Result {
194 core::fmt::Formatter::write_str(__formatter, "field identifier")
195 }
196 #[allow(clippy::match_single_binding)]
198 #[allow(clippy::reversed_empty_ranges)]
199 #[allow(clippy::single_match)]
200 fn visit_key<__E>(
201 self,
202 __value: &str,
203 ) -> core::result::Result<Self::Value, __E>
204 where
205 __E: _serde::de::Error,
206 {
207 match __value {
208 "targetPosition" => Ok(__Field::m_targetPosition),
209 "targetRotation" => Ok(__Field::m_targetRotation),
210 "targetNormal" => Ok(__Field::m_targetNormal),
211 "targetHandle" => Ok(__Field::m_targetHandle),
212 "transformOnFraction" => Ok(__Field::m_transformOnFraction),
213 "normalOnFraction" => Ok(__Field::m_normalOnFraction),
214 "fadeInDuration" => Ok(__Field::m_fadeInDuration),
215 "fadeOutDuration" => Ok(__Field::m_fadeOutDuration),
216 "extrapolationTimeStep" => Ok(__Field::m_extrapolationTimeStep),
217 "handleChangeSpeed" => Ok(__Field::m_handleChangeSpeed),
218 "handleChangeMode" => Ok(__Field::m_handleChangeMode),
219 "fixUp" => Ok(__Field::m_fixUp),
220 _ => Ok(__Field::__ignore),
221 }
222 }
223 }
224 impl<'de> _serde::Deserialize<'de> for __Field {
225 #[inline]
226 fn deserialize<__D>(
227 __deserializer: __D,
228 ) -> core::result::Result<Self, __D::Error>
229 where
230 __D: _serde::Deserializer<'de>,
231 {
232 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
233 }
234 }
235 struct __hkbHandIkControlDataVisitor<'de> {
236 marker: _serde::__private::PhantomData<hkbHandIkControlData>,
237 lifetime: _serde::__private::PhantomData<&'de ()>,
238 }
239 #[allow(clippy::match_single_binding)]
240 #[allow(clippy::reversed_empty_ranges)]
241 #[allow(clippy::single_match)]
242 impl<'de> _serde::de::Visitor<'de> for __hkbHandIkControlDataVisitor<'de> {
243 type Value = hkbHandIkControlData;
244 fn expecting(
245 &self,
246 __formatter: &mut core::fmt::Formatter,
247 ) -> core::fmt::Result {
248 core::fmt::Formatter::write_str(
249 __formatter,
250 "struct hkbHandIkControlData",
251 )
252 }
253 fn visit_struct_for_bytes<__A>(
254 self,
255 mut __map: __A,
256 ) -> _serde::__private::Result<Self::Value, __A::Error>
257 where
258 __A: _serde::de::MapAccess<'de>,
259 {
260 let __ptr = __A::class_ptr(&mut __map);
261 let mut m_targetPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
262 let mut m_targetRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
263 let mut m_targetNormal: _serde::__private::Option<Vector4> = _serde::__private::None;
264 let mut m_targetHandle: _serde::__private::Option<Pointer> = _serde::__private::None;
265 let mut m_transformOnFraction: _serde::__private::Option<f32> = _serde::__private::None;
266 let mut m_normalOnFraction: _serde::__private::Option<f32> = _serde::__private::None;
267 let mut m_fadeInDuration: _serde::__private::Option<f32> = _serde::__private::None;
268 let mut m_fadeOutDuration: _serde::__private::Option<f32> = _serde::__private::None;
269 let mut m_extrapolationTimeStep: _serde::__private::Option<f32> = _serde::__private::None;
270 let mut m_handleChangeSpeed: _serde::__private::Option<f32> = _serde::__private::None;
271 let mut m_handleChangeMode: _serde::__private::Option<
272 HandleChangeMode,
273 > = _serde::__private::None;
274 let mut m_fixUp: _serde::__private::Option<bool> = _serde::__private::None;
275 for i in 0..12usize {
276 match i {
277 0usize => {
278 if _serde::__private::Option::is_some(&m_targetPosition) {
279 return _serde::__private::Err(
280 <__A::Error as _serde::de::Error>::duplicate_field(
281 "targetPosition",
282 ),
283 );
284 }
285 m_targetPosition = _serde::__private::Some(
286 match __A::next_value::<Vector4>(&mut __map) {
287 _serde::__private::Ok(__val) => __val,
288 _serde::__private::Err(__err) => {
289 return _serde::__private::Err(__err);
290 }
291 },
292 );
293 }
294 1usize => {
295 if _serde::__private::Option::is_some(&m_targetRotation) {
296 return _serde::__private::Err(
297 <__A::Error as _serde::de::Error>::duplicate_field(
298 "targetRotation",
299 ),
300 );
301 }
302 m_targetRotation = _serde::__private::Some(
303 match __A::next_value::<Quaternion>(&mut __map) {
304 _serde::__private::Ok(__val) => __val,
305 _serde::__private::Err(__err) => {
306 return _serde::__private::Err(__err);
307 }
308 },
309 );
310 }
311 2usize => {
312 if _serde::__private::Option::is_some(&m_targetNormal) {
313 return _serde::__private::Err(
314 <__A::Error as _serde::de::Error>::duplicate_field(
315 "targetNormal",
316 ),
317 );
318 }
319 m_targetNormal = _serde::__private::Some(
320 match __A::next_value::<Vector4>(&mut __map) {
321 _serde::__private::Ok(__val) => __val,
322 _serde::__private::Err(__err) => {
323 return _serde::__private::Err(__err);
324 }
325 },
326 );
327 }
328 3usize => {
329 if _serde::__private::Option::is_some(&m_targetHandle) {
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::duplicate_field(
332 "targetHandle",
333 ),
334 );
335 }
336 m_targetHandle = _serde::__private::Some(
337 match __A::next_value::<Pointer>(&mut __map) {
338 _serde::__private::Ok(__val) => __val,
339 _serde::__private::Err(__err) => {
340 return _serde::__private::Err(__err);
341 }
342 },
343 );
344 }
345 4usize => {
346 if _serde::__private::Option::is_some(
347 &m_transformOnFraction,
348 ) {
349 return _serde::__private::Err(
350 <__A::Error as _serde::de::Error>::duplicate_field(
351 "transformOnFraction",
352 ),
353 );
354 }
355 m_transformOnFraction = _serde::__private::Some(
356 match __A::next_value::<f32>(&mut __map) {
357 _serde::__private::Ok(__val) => __val,
358 _serde::__private::Err(__err) => {
359 return _serde::__private::Err(__err);
360 }
361 },
362 );
363 }
364 5usize => {
365 if _serde::__private::Option::is_some(&m_normalOnFraction) {
366 return _serde::__private::Err(
367 <__A::Error as _serde::de::Error>::duplicate_field(
368 "normalOnFraction",
369 ),
370 );
371 }
372 m_normalOnFraction = _serde::__private::Some(
373 match __A::next_value::<f32>(&mut __map) {
374 _serde::__private::Ok(__val) => __val,
375 _serde::__private::Err(__err) => {
376 return _serde::__private::Err(__err);
377 }
378 },
379 );
380 }
381 6usize => {
382 if _serde::__private::Option::is_some(&m_fadeInDuration) {
383 return _serde::__private::Err(
384 <__A::Error as _serde::de::Error>::duplicate_field(
385 "fadeInDuration",
386 ),
387 );
388 }
389 m_fadeInDuration = _serde::__private::Some(
390 match __A::next_value::<f32>(&mut __map) {
391 _serde::__private::Ok(__val) => __val,
392 _serde::__private::Err(__err) => {
393 return _serde::__private::Err(__err);
394 }
395 },
396 );
397 }
398 7usize => {
399 if _serde::__private::Option::is_some(&m_fadeOutDuration) {
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::duplicate_field(
402 "fadeOutDuration",
403 ),
404 );
405 }
406 m_fadeOutDuration = _serde::__private::Some(
407 match __A::next_value::<f32>(&mut __map) {
408 _serde::__private::Ok(__val) => __val,
409 _serde::__private::Err(__err) => {
410 return _serde::__private::Err(__err);
411 }
412 },
413 );
414 }
415 8usize => {
416 if _serde::__private::Option::is_some(
417 &m_extrapolationTimeStep,
418 ) {
419 return _serde::__private::Err(
420 <__A::Error as _serde::de::Error>::duplicate_field(
421 "extrapolationTimeStep",
422 ),
423 );
424 }
425 m_extrapolationTimeStep = _serde::__private::Some(
426 match __A::next_value::<f32>(&mut __map) {
427 _serde::__private::Ok(__val) => __val,
428 _serde::__private::Err(__err) => {
429 return _serde::__private::Err(__err);
430 }
431 },
432 );
433 }
434 9usize => {
435 if _serde::__private::Option::is_some(
436 &m_handleChangeSpeed,
437 ) {
438 return _serde::__private::Err(
439 <__A::Error as _serde::de::Error>::duplicate_field(
440 "handleChangeSpeed",
441 ),
442 );
443 }
444 m_handleChangeSpeed = _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 10usize => {
454 if _serde::__private::Option::is_some(&m_handleChangeMode) {
455 return _serde::__private::Err(
456 <__A::Error as _serde::de::Error>::duplicate_field(
457 "handleChangeMode",
458 ),
459 );
460 }
461 m_handleChangeMode = _serde::__private::Some(
462 match __A::next_value::<HandleChangeMode>(&mut __map) {
463 _serde::__private::Ok(__val) => __val,
464 _serde::__private::Err(__err) => {
465 return _serde::__private::Err(__err);
466 }
467 },
468 );
469 }
470 11usize => {
471 if _serde::__private::Option::is_some(&m_fixUp) {
472 return _serde::__private::Err(
473 <__A::Error as _serde::de::Error>::duplicate_field("fixUp"),
474 );
475 }
476 m_fixUp = _serde::__private::Some(
477 match __A::next_value::<bool>(&mut __map) {
478 _serde::__private::Ok(__val) => __val,
479 _serde::__private::Err(__err) => {
480 return _serde::__private::Err(__err);
481 }
482 },
483 );
484 }
485 _ => {}
486 }
487 }
488 __A::pad(&mut __map, 2usize, 14usize)?;
489 let m_targetPosition = match m_targetPosition {
490 _serde::__private::Some(__field) => __field,
491 _serde::__private::None => {
492 return _serde::__private::Err(
493 <__A::Error as _serde::de::Error>::missing_field(
494 "targetPosition",
495 ),
496 );
497 }
498 };
499 let m_targetRotation = match m_targetRotation {
500 _serde::__private::Some(__field) => __field,
501 _serde::__private::None => {
502 return _serde::__private::Err(
503 <__A::Error as _serde::de::Error>::missing_field(
504 "targetRotation",
505 ),
506 );
507 }
508 };
509 let m_targetNormal = match m_targetNormal {
510 _serde::__private::Some(__field) => __field,
511 _serde::__private::None => {
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::missing_field(
514 "targetNormal",
515 ),
516 );
517 }
518 };
519 let m_targetHandle = match m_targetHandle {
520 _serde::__private::Some(__field) => __field,
521 _serde::__private::None => {
522 return _serde::__private::Err(
523 <__A::Error as _serde::de::Error>::missing_field(
524 "targetHandle",
525 ),
526 );
527 }
528 };
529 let m_transformOnFraction = match m_transformOnFraction {
530 _serde::__private::Some(__field) => __field,
531 _serde::__private::None => {
532 return _serde::__private::Err(
533 <__A::Error as _serde::de::Error>::missing_field(
534 "transformOnFraction",
535 ),
536 );
537 }
538 };
539 let m_normalOnFraction = match m_normalOnFraction {
540 _serde::__private::Some(__field) => __field,
541 _serde::__private::None => {
542 return _serde::__private::Err(
543 <__A::Error as _serde::de::Error>::missing_field(
544 "normalOnFraction",
545 ),
546 );
547 }
548 };
549 let m_fadeInDuration = match m_fadeInDuration {
550 _serde::__private::Some(__field) => __field,
551 _serde::__private::None => {
552 return _serde::__private::Err(
553 <__A::Error as _serde::de::Error>::missing_field(
554 "fadeInDuration",
555 ),
556 );
557 }
558 };
559 let m_fadeOutDuration = match m_fadeOutDuration {
560 _serde::__private::Some(__field) => __field,
561 _serde::__private::None => {
562 return _serde::__private::Err(
563 <__A::Error as _serde::de::Error>::missing_field(
564 "fadeOutDuration",
565 ),
566 );
567 }
568 };
569 let m_extrapolationTimeStep = match m_extrapolationTimeStep {
570 _serde::__private::Some(__field) => __field,
571 _serde::__private::None => {
572 return _serde::__private::Err(
573 <__A::Error as _serde::de::Error>::missing_field(
574 "extrapolationTimeStep",
575 ),
576 );
577 }
578 };
579 let m_handleChangeSpeed = match m_handleChangeSpeed {
580 _serde::__private::Some(__field) => __field,
581 _serde::__private::None => {
582 return _serde::__private::Err(
583 <__A::Error as _serde::de::Error>::missing_field(
584 "handleChangeSpeed",
585 ),
586 );
587 }
588 };
589 let m_handleChangeMode = match m_handleChangeMode {
590 _serde::__private::Some(__field) => __field,
591 _serde::__private::None => {
592 return _serde::__private::Err(
593 <__A::Error as _serde::de::Error>::missing_field(
594 "handleChangeMode",
595 ),
596 );
597 }
598 };
599 let m_fixUp = match m_fixUp {
600 _serde::__private::Some(__field) => __field,
601 _serde::__private::None => {
602 return _serde::__private::Err(
603 <__A::Error as _serde::de::Error>::missing_field("fixUp"),
604 );
605 }
606 };
607 _serde::__private::Ok(hkbHandIkControlData {
608 __ptr,
609 m_targetPosition,
610 m_targetRotation,
611 m_targetNormal,
612 m_targetHandle,
613 m_transformOnFraction,
614 m_normalOnFraction,
615 m_fadeInDuration,
616 m_fadeOutDuration,
617 m_extrapolationTimeStep,
618 m_handleChangeSpeed,
619 m_handleChangeMode,
620 m_fixUp,
621 })
622 }
623 #[allow(clippy::manual_unwrap_or_default)]
624 fn visit_struct<__A>(
625 self,
626 mut __map: __A,
627 ) -> _serde::__private::Result<Self::Value, __A::Error>
628 where
629 __A: _serde::de::MapAccess<'de>,
630 {
631 let mut m_targetPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
632 let mut m_targetRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
633 let mut m_targetNormal: _serde::__private::Option<Vector4> = _serde::__private::None;
634 let mut m_targetHandle: _serde::__private::Option<Pointer> = _serde::__private::None;
635 let mut m_transformOnFraction: _serde::__private::Option<f32> = _serde::__private::None;
636 let mut m_normalOnFraction: _serde::__private::Option<f32> = _serde::__private::None;
637 let mut m_fadeInDuration: _serde::__private::Option<f32> = _serde::__private::None;
638 let mut m_fadeOutDuration: _serde::__private::Option<f32> = _serde::__private::None;
639 let mut m_extrapolationTimeStep: _serde::__private::Option<f32> = _serde::__private::None;
640 let mut m_handleChangeSpeed: _serde::__private::Option<f32> = _serde::__private::None;
641 let mut m_handleChangeMode: _serde::__private::Option<
642 HandleChangeMode,
643 > = _serde::__private::None;
644 let mut m_fixUp: _serde::__private::Option<bool> = _serde::__private::None;
645 while let _serde::__private::Some(__key) = {
646 __A::next_key::<__Field>(&mut __map)?
647 } {
648 match __key {
649 __Field::m_targetPosition => {
650 #[cfg(
651 any(feature = "strict", feature = "ignore_duplicates")
652 )]
653 if _serde::__private::Option::is_some(&m_targetPosition) {
654 #[cfg(feature = "ignore_duplicates")]
655 {
656 __A::skip_value(&mut __map)?;
657 continue;
658 }
659 #[cfg(feature = "strict")]
660 return _serde::__private::Err(
661 <__A::Error as _serde::de::Error>::duplicate_field(
662 "targetPosition",
663 ),
664 );
665 }
666 m_targetPosition = _serde::__private::Some(
667 match __A::next_value::<Vector4>(&mut __map) {
668 _serde::__private::Ok(__val) => __val,
669 _serde::__private::Err(__err) => {
670 return _serde::__private::Err(__err);
671 }
672 },
673 );
674 }
675 __Field::m_targetRotation => {
676 #[cfg(
677 any(feature = "strict", feature = "ignore_duplicates")
678 )]
679 if _serde::__private::Option::is_some(&m_targetRotation) {
680 #[cfg(feature = "ignore_duplicates")]
681 {
682 __A::skip_value(&mut __map)?;
683 continue;
684 }
685 #[cfg(feature = "strict")]
686 return _serde::__private::Err(
687 <__A::Error as _serde::de::Error>::duplicate_field(
688 "targetRotation",
689 ),
690 );
691 }
692 m_targetRotation = _serde::__private::Some(
693 match __A::next_value::<Quaternion>(&mut __map) {
694 _serde::__private::Ok(__val) => __val,
695 _serde::__private::Err(__err) => {
696 return _serde::__private::Err(__err);
697 }
698 },
699 );
700 }
701 __Field::m_targetNormal => {
702 #[cfg(
703 any(feature = "strict", feature = "ignore_duplicates")
704 )]
705 if _serde::__private::Option::is_some(&m_targetNormal) {
706 #[cfg(feature = "ignore_duplicates")]
707 {
708 __A::skip_value(&mut __map)?;
709 continue;
710 }
711 #[cfg(feature = "strict")]
712 return _serde::__private::Err(
713 <__A::Error as _serde::de::Error>::duplicate_field(
714 "targetNormal",
715 ),
716 );
717 }
718 m_targetNormal = _serde::__private::Some(
719 match __A::next_value::<Vector4>(&mut __map) {
720 _serde::__private::Ok(__val) => __val,
721 _serde::__private::Err(__err) => {
722 return _serde::__private::Err(__err);
723 }
724 },
725 );
726 }
727 __Field::m_targetHandle => {
728 #[cfg(
729 any(feature = "strict", feature = "ignore_duplicates")
730 )]
731 if _serde::__private::Option::is_some(&m_targetHandle) {
732 #[cfg(feature = "ignore_duplicates")]
733 {
734 __A::skip_value(&mut __map)?;
735 continue;
736 }
737 #[cfg(feature = "strict")]
738 return _serde::__private::Err(
739 <__A::Error as _serde::de::Error>::duplicate_field(
740 "targetHandle",
741 ),
742 );
743 }
744 m_targetHandle = _serde::__private::Some(
745 match __A::next_value::<Pointer>(&mut __map) {
746 _serde::__private::Ok(__val) => __val,
747 _serde::__private::Err(__err) => {
748 return _serde::__private::Err(__err);
749 }
750 },
751 );
752 }
753 __Field::m_transformOnFraction => {
754 #[cfg(
755 any(feature = "strict", feature = "ignore_duplicates")
756 )]
757 if _serde::__private::Option::is_some(
758 &m_transformOnFraction,
759 ) {
760 #[cfg(feature = "ignore_duplicates")]
761 {
762 __A::skip_value(&mut __map)?;
763 continue;
764 }
765 #[cfg(feature = "strict")]
766 return _serde::__private::Err(
767 <__A::Error as _serde::de::Error>::duplicate_field(
768 "transformOnFraction",
769 ),
770 );
771 }
772 m_transformOnFraction = _serde::__private::Some(
773 match __A::next_value::<f32>(&mut __map) {
774 _serde::__private::Ok(__val) => __val,
775 _serde::__private::Err(__err) => {
776 return _serde::__private::Err(__err);
777 }
778 },
779 );
780 }
781 __Field::m_normalOnFraction => {
782 #[cfg(
783 any(feature = "strict", feature = "ignore_duplicates")
784 )]
785 if _serde::__private::Option::is_some(&m_normalOnFraction) {
786 #[cfg(feature = "ignore_duplicates")]
787 {
788 __A::skip_value(&mut __map)?;
789 continue;
790 }
791 #[cfg(feature = "strict")]
792 return _serde::__private::Err(
793 <__A::Error as _serde::de::Error>::duplicate_field(
794 "normalOnFraction",
795 ),
796 );
797 }
798 m_normalOnFraction = _serde::__private::Some(
799 match __A::next_value::<f32>(&mut __map) {
800 _serde::__private::Ok(__val) => __val,
801 _serde::__private::Err(__err) => {
802 return _serde::__private::Err(__err);
803 }
804 },
805 );
806 }
807 __Field::m_fadeInDuration => {
808 #[cfg(
809 any(feature = "strict", feature = "ignore_duplicates")
810 )]
811 if _serde::__private::Option::is_some(&m_fadeInDuration) {
812 #[cfg(feature = "ignore_duplicates")]
813 {
814 __A::skip_value(&mut __map)?;
815 continue;
816 }
817 #[cfg(feature = "strict")]
818 return _serde::__private::Err(
819 <__A::Error as _serde::de::Error>::duplicate_field(
820 "fadeInDuration",
821 ),
822 );
823 }
824 m_fadeInDuration = _serde::__private::Some(
825 match __A::next_value::<f32>(&mut __map) {
826 _serde::__private::Ok(__val) => __val,
827 _serde::__private::Err(__err) => {
828 return _serde::__private::Err(__err);
829 }
830 },
831 );
832 }
833 __Field::m_fadeOutDuration => {
834 #[cfg(
835 any(feature = "strict", feature = "ignore_duplicates")
836 )]
837 if _serde::__private::Option::is_some(&m_fadeOutDuration) {
838 #[cfg(feature = "ignore_duplicates")]
839 {
840 __A::skip_value(&mut __map)?;
841 continue;
842 }
843 #[cfg(feature = "strict")]
844 return _serde::__private::Err(
845 <__A::Error as _serde::de::Error>::duplicate_field(
846 "fadeOutDuration",
847 ),
848 );
849 }
850 m_fadeOutDuration = _serde::__private::Some(
851 match __A::next_value::<f32>(&mut __map) {
852 _serde::__private::Ok(__val) => __val,
853 _serde::__private::Err(__err) => {
854 return _serde::__private::Err(__err);
855 }
856 },
857 );
858 }
859 __Field::m_extrapolationTimeStep => {
860 #[cfg(
861 any(feature = "strict", feature = "ignore_duplicates")
862 )]
863 if _serde::__private::Option::is_some(
864 &m_extrapolationTimeStep,
865 ) {
866 #[cfg(feature = "ignore_duplicates")]
867 {
868 __A::skip_value(&mut __map)?;
869 continue;
870 }
871 #[cfg(feature = "strict")]
872 return _serde::__private::Err(
873 <__A::Error as _serde::de::Error>::duplicate_field(
874 "extrapolationTimeStep",
875 ),
876 );
877 }
878 m_extrapolationTimeStep = _serde::__private::Some(
879 match __A::next_value::<f32>(&mut __map) {
880 _serde::__private::Ok(__val) => __val,
881 _serde::__private::Err(__err) => {
882 return _serde::__private::Err(__err);
883 }
884 },
885 );
886 }
887 __Field::m_handleChangeSpeed => {
888 #[cfg(
889 any(feature = "strict", feature = "ignore_duplicates")
890 )]
891 if _serde::__private::Option::is_some(
892 &m_handleChangeSpeed,
893 ) {
894 #[cfg(feature = "ignore_duplicates")]
895 {
896 __A::skip_value(&mut __map)?;
897 continue;
898 }
899 #[cfg(feature = "strict")]
900 return _serde::__private::Err(
901 <__A::Error as _serde::de::Error>::duplicate_field(
902 "handleChangeSpeed",
903 ),
904 );
905 }
906 m_handleChangeSpeed = _serde::__private::Some(
907 match __A::next_value::<f32>(&mut __map) {
908 _serde::__private::Ok(__val) => __val,
909 _serde::__private::Err(__err) => {
910 return _serde::__private::Err(__err);
911 }
912 },
913 );
914 }
915 __Field::m_handleChangeMode => {
916 #[cfg(
917 any(feature = "strict", feature = "ignore_duplicates")
918 )]
919 if _serde::__private::Option::is_some(&m_handleChangeMode) {
920 #[cfg(feature = "ignore_duplicates")]
921 {
922 __A::skip_value(&mut __map)?;
923 continue;
924 }
925 #[cfg(feature = "strict")]
926 return _serde::__private::Err(
927 <__A::Error as _serde::de::Error>::duplicate_field(
928 "handleChangeMode",
929 ),
930 );
931 }
932 m_handleChangeMode = _serde::__private::Some(
933 match __A::next_value::<HandleChangeMode>(&mut __map) {
934 _serde::__private::Ok(__val) => __val,
935 _serde::__private::Err(__err) => {
936 return _serde::__private::Err(__err);
937 }
938 },
939 );
940 }
941 __Field::m_fixUp => {
942 #[cfg(
943 any(feature = "strict", feature = "ignore_duplicates")
944 )]
945 if _serde::__private::Option::is_some(&m_fixUp) {
946 #[cfg(feature = "ignore_duplicates")]
947 {
948 __A::skip_value(&mut __map)?;
949 continue;
950 }
951 #[cfg(feature = "strict")]
952 return _serde::__private::Err(
953 <__A::Error as _serde::de::Error>::duplicate_field("fixUp"),
954 );
955 }
956 m_fixUp = _serde::__private::Some(
957 match __A::next_value::<bool>(&mut __map) {
958 _serde::__private::Ok(__val) => __val,
959 _serde::__private::Err(__err) => {
960 return _serde::__private::Err(__err);
961 }
962 },
963 );
964 }
965 _ => __A::skip_value(&mut __map)?,
966 }
967 }
968 let m_targetPosition = match m_targetPosition {
969 _serde::__private::Some(__field) => __field,
970 _serde::__private::None => {
971 #[cfg(feature = "strict")]
972 return _serde::__private::Err(
973 <__A::Error as _serde::de::Error>::missing_field(
974 "targetPosition",
975 ),
976 );
977 #[cfg(not(feature = "strict"))] Default::default()
978 }
979 };
980 let m_targetRotation = match m_targetRotation {
981 _serde::__private::Some(__field) => __field,
982 _serde::__private::None => {
983 #[cfg(feature = "strict")]
984 return _serde::__private::Err(
985 <__A::Error as _serde::de::Error>::missing_field(
986 "targetRotation",
987 ),
988 );
989 #[cfg(not(feature = "strict"))] Default::default()
990 }
991 };
992 let m_targetNormal = match m_targetNormal {
993 _serde::__private::Some(__field) => __field,
994 _serde::__private::None => {
995 #[cfg(feature = "strict")]
996 return _serde::__private::Err(
997 <__A::Error as _serde::de::Error>::missing_field(
998 "targetNormal",
999 ),
1000 );
1001 #[cfg(not(feature = "strict"))] Default::default()
1002 }
1003 };
1004 let m_targetHandle = match m_targetHandle {
1005 _serde::__private::Some(__field) => __field,
1006 _serde::__private::None => {
1007 #[cfg(feature = "strict")]
1008 return _serde::__private::Err(
1009 <__A::Error as _serde::de::Error>::missing_field(
1010 "targetHandle",
1011 ),
1012 );
1013 #[cfg(not(feature = "strict"))] Default::default()
1014 }
1015 };
1016 let m_transformOnFraction = match m_transformOnFraction {
1017 _serde::__private::Some(__field) => __field,
1018 _serde::__private::None => {
1019 #[cfg(feature = "strict")]
1020 return _serde::__private::Err(
1021 <__A::Error as _serde::de::Error>::missing_field(
1022 "transformOnFraction",
1023 ),
1024 );
1025 #[cfg(not(feature = "strict"))] Default::default()
1026 }
1027 };
1028 let m_normalOnFraction = match m_normalOnFraction {
1029 _serde::__private::Some(__field) => __field,
1030 _serde::__private::None => {
1031 #[cfg(feature = "strict")]
1032 return _serde::__private::Err(
1033 <__A::Error as _serde::de::Error>::missing_field(
1034 "normalOnFraction",
1035 ),
1036 );
1037 #[cfg(not(feature = "strict"))] Default::default()
1038 }
1039 };
1040 let m_fadeInDuration = match m_fadeInDuration {
1041 _serde::__private::Some(__field) => __field,
1042 _serde::__private::None => {
1043 #[cfg(feature = "strict")]
1044 return _serde::__private::Err(
1045 <__A::Error as _serde::de::Error>::missing_field(
1046 "fadeInDuration",
1047 ),
1048 );
1049 #[cfg(not(feature = "strict"))] Default::default()
1050 }
1051 };
1052 let m_fadeOutDuration = match m_fadeOutDuration {
1053 _serde::__private::Some(__field) => __field,
1054 _serde::__private::None => {
1055 #[cfg(feature = "strict")]
1056 return _serde::__private::Err(
1057 <__A::Error as _serde::de::Error>::missing_field(
1058 "fadeOutDuration",
1059 ),
1060 );
1061 #[cfg(not(feature = "strict"))] Default::default()
1062 }
1063 };
1064 let m_extrapolationTimeStep = match m_extrapolationTimeStep {
1065 _serde::__private::Some(__field) => __field,
1066 _serde::__private::None => {
1067 #[cfg(feature = "strict")]
1068 return _serde::__private::Err(
1069 <__A::Error as _serde::de::Error>::missing_field(
1070 "extrapolationTimeStep",
1071 ),
1072 );
1073 #[cfg(not(feature = "strict"))] Default::default()
1074 }
1075 };
1076 let m_handleChangeSpeed = match m_handleChangeSpeed {
1077 _serde::__private::Some(__field) => __field,
1078 _serde::__private::None => {
1079 #[cfg(feature = "strict")]
1080 return _serde::__private::Err(
1081 <__A::Error as _serde::de::Error>::missing_field(
1082 "handleChangeSpeed",
1083 ),
1084 );
1085 #[cfg(not(feature = "strict"))] Default::default()
1086 }
1087 };
1088 let m_handleChangeMode = match m_handleChangeMode {
1089 _serde::__private::Some(__field) => __field,
1090 _serde::__private::None => {
1091 #[cfg(feature = "strict")]
1092 return _serde::__private::Err(
1093 <__A::Error as _serde::de::Error>::missing_field(
1094 "handleChangeMode",
1095 ),
1096 );
1097 #[cfg(not(feature = "strict"))] Default::default()
1098 }
1099 };
1100 let m_fixUp = match m_fixUp {
1101 _serde::__private::Some(__field) => __field,
1102 _serde::__private::None => {
1103 #[cfg(feature = "strict")]
1104 return _serde::__private::Err(
1105 <__A::Error as _serde::de::Error>::missing_field("fixUp"),
1106 );
1107 #[cfg(not(feature = "strict"))] Default::default()
1108 }
1109 };
1110 let __ptr = __A::class_ptr(&mut __map);
1111 _serde::__private::Ok(hkbHandIkControlData {
1112 __ptr,
1113 m_targetPosition,
1114 m_targetRotation,
1115 m_targetNormal,
1116 m_targetHandle,
1117 m_transformOnFraction,
1118 m_normalOnFraction,
1119 m_fadeInDuration,
1120 m_fadeOutDuration,
1121 m_extrapolationTimeStep,
1122 m_handleChangeSpeed,
1123 m_handleChangeMode,
1124 m_fixUp,
1125 })
1126 }
1127 }
1128 const FIELDS: &[&str] = &[
1129 "targetPosition",
1130 "targetRotation",
1131 "targetNormal",
1132 "targetHandle",
1133 "transformOnFraction",
1134 "normalOnFraction",
1135 "fadeInDuration",
1136 "fadeOutDuration",
1137 "extrapolationTimeStep",
1138 "handleChangeSpeed",
1139 "handleChangeMode",
1140 "fixUp",
1141 ];
1142 _serde::Deserializer::deserialize_struct(
1143 deserializer,
1144 "hkbHandIkControlData",
1145 FIELDS,
1146 __hkbHandIkControlDataVisitor {
1147 marker: _serde::__private::PhantomData::<hkbHandIkControlData>,
1148 lifetime: _serde::__private::PhantomData,
1149 },
1150 )
1151 }
1152 }
1153};
1154#[allow(non_upper_case_globals, non_snake_case)]
1157#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1158#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1159#[derive(
1160 Debug,
1161 Clone,
1162 Default,
1163 PartialEq,
1164 Eq,
1165 PartialOrd,
1166 Ord,
1167 num_derive::ToPrimitive,
1168 num_derive::FromPrimitive,
1169)]
1170pub enum HandleChangeMode {
1171 #[default]
1172 HANDLE_CHANGE_MODE_ABRUPT = 0isize,
1173 HANDLE_CHANGE_MODE_CONSTANT_VELOCITY = 1isize,
1174}
1175const _: () = {
1176 use havok_serde as __serde;
1177 impl __serde::Serialize for HandleChangeMode {
1178 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1179 where
1180 S: __serde::ser::Serializer,
1181 {
1182 let mut __serializer = __serializer.serialize_enum_flags()?;
1183 match self {
1184 Self::HANDLE_CHANGE_MODE_ABRUPT => {
1185 __serializer.serialize_field("HANDLE_CHANGE_MODE_ABRUPT", &0u64)
1186 }
1187 Self::HANDLE_CHANGE_MODE_CONSTANT_VELOCITY => {
1188 __serializer
1189 .serialize_field("HANDLE_CHANGE_MODE_CONSTANT_VELOCITY", &1u64)
1190 }
1191 }?;
1192 use num_traits::ToPrimitive as _;
1193 let num = self
1194 .to_i8()
1195 .ok_or(S::Error::custom("Failed enum HandleChangeMode to_i8"))?;
1196 __serializer.serialize_bits(&num)?;
1197 __serializer.end()
1198 }
1199 }
1200};
1201#[doc(hidden)]
1202#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1203const _: () = {
1204 #[allow(unused_extern_crates, clippy::useless_attribute)]
1205 extern crate havok_serde as _serde;
1206 #[automatically_derived]
1207 impl<'de> _serde::Deserialize<'de> for HandleChangeMode {
1208 fn deserialize<__D>(
1209 __deserializer: __D,
1210 ) -> _serde::__private::Result<Self, __D::Error>
1211 where
1212 __D: _serde::Deserializer<'de>,
1213 {
1214 #[allow(non_camel_case_types)]
1215 #[doc(hidden)]
1216 enum __Field {
1217 __field0,
1218 __field1,
1219 }
1220 #[doc(hidden)]
1221 struct __FieldVisitor;
1222 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1223 type Value = __Field;
1224 fn expecting(
1225 &self,
1226 __formatter: &mut _serde::__private::Formatter,
1227 ) -> _serde::__private::fmt::Result {
1228 _serde::__private::Formatter::write_str(
1229 __formatter,
1230 "variant identifier",
1231 )
1232 }
1233 fn visit_int8<__E>(
1234 self,
1235 __value: i8,
1236 ) -> _serde::__private::Result<Self::Value, __E>
1237 where
1238 __E: _serde::de::Error,
1239 {
1240 match __value {
1241 0i8 => _serde::__private::Ok(__Field::__field0),
1242 1i8 => _serde::__private::Ok(__Field::__field1),
1243 _ => {
1244 _serde::__private::Err(
1245 _serde::de::Error::invalid_value(
1246 _serde::de::Unexpected::Int8(__value),
1247 &"value(i8) of variant is one of 0, 1",
1248 ),
1249 )
1250 }
1251 }
1252 }
1253 fn visit_stringptr<__E>(
1254 self,
1255 __value: StringPtr<'de>,
1256 ) -> _serde::__private::Result<Self::Value, __E>
1257 where
1258 __E: _serde::de::Error,
1259 {
1260 if let Some(__value) = __value.into_inner() {
1261 match __value.as_ref() {
1262 v if v == "0"
1263 || v.eq_ignore_ascii_case("HANDLE_CHANGE_MODE_ABRUPT") => {
1264 _serde::__private::Ok(__Field::__field0)
1265 }
1266 v if v == "1"
1267 || v
1268 .eq_ignore_ascii_case(
1269 "HANDLE_CHANGE_MODE_CONSTANT_VELOCITY",
1270 ) => _serde::__private::Ok(__Field::__field1),
1271 _ => {
1272 _serde::__private::Err(
1273 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1274 )
1275 }
1276 }
1277 } else {
1278 _serde::__private::Err(
1279 _serde::de::Error::unknown_variant("None", VARIANTS),
1280 )
1281 }
1282 }
1283 }
1284 impl<'de> _serde::Deserialize<'de> for __Field {
1285 #[inline]
1286 fn deserialize<__D>(
1287 __deserializer: __D,
1288 ) -> _serde::__private::Result<Self, __D::Error>
1289 where
1290 __D: _serde::Deserializer<'de>,
1291 {
1292 _serde::Deserializer::deserialize_identifier(
1293 __deserializer,
1294 _serde::de::ReadEnumSize::Int8,
1295 __FieldVisitor,
1296 )
1297 }
1298 }
1299 #[doc(hidden)]
1300 struct __Visitor<'de> {
1301 marker: _serde::__private::PhantomData<HandleChangeMode>,
1302 lifetime: _serde::__private::PhantomData<&'de ()>,
1303 }
1304 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1305 type Value = HandleChangeMode;
1306 fn expecting(
1307 &self,
1308 __formatter: &mut _serde::__private::Formatter,
1309 ) -> _serde::__private::fmt::Result {
1310 _serde::__private::Formatter::write_str(
1311 __formatter,
1312 "enum HandleChangeMode",
1313 )
1314 }
1315 fn visit_enum<__A>(
1316 self,
1317 __data: __A,
1318 ) -> _serde::__private::Result<Self::Value, __A::Error>
1319 where
1320 __A: _serde::de::EnumAccess<'de>,
1321 {
1322 match _serde::de::EnumAccess::variant(__data)? {
1323 (__Field::__field0, __variant) => {
1324 _serde::de::VariantAccess::unit_variant(__variant)?;
1325 _serde::__private::Ok(
1326 HandleChangeMode::HANDLE_CHANGE_MODE_ABRUPT,
1327 )
1328 }
1329 (__Field::__field1, __variant) => {
1330 _serde::de::VariantAccess::unit_variant(__variant)?;
1331 _serde::__private::Ok(
1332 HandleChangeMode::HANDLE_CHANGE_MODE_CONSTANT_VELOCITY,
1333 )
1334 }
1335 }
1336 }
1337 }
1338 #[doc(hidden)]
1339 const VARIANTS: &'static [&'static str] = &[
1340 "HANDLE_CHANGE_MODE_ABRUPT",
1341 "HANDLE_CHANGE_MODE_CONSTANT_VELOCITY",
1342 ];
1343 _serde::Deserializer::deserialize_enum(
1344 __deserializer,
1345 "HandleChangeMode",
1346 VARIANTS,
1347 __Visitor {
1348 marker: _serde::__private::PhantomData::<HandleChangeMode>,
1349 lifetime: _serde::__private::PhantomData,
1350 },
1351 )
1352 }
1353 }
1354};