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 hkbComputeRotationToTargetModifier<'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 = "targetPosition"))]
43 #[cfg_attr(feature = "serde", serde(rename = "targetPosition"))]
44 pub m_targetPosition: Vector4,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "currentPosition"))]
50 #[cfg_attr(feature = "serde", serde(rename = "currentPosition"))]
51 pub m_currentPosition: Vector4,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "currentRotation"))]
57 #[cfg_attr(feature = "serde", serde(rename = "currentRotation"))]
58 pub m_currentRotation: Quaternion,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "localAxisOfRotation"))]
64 #[cfg_attr(feature = "serde", serde(rename = "localAxisOfRotation"))]
65 pub m_localAxisOfRotation: Vector4,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "localFacingDirection"))]
71 #[cfg_attr(feature = "serde", serde(rename = "localFacingDirection"))]
72 pub m_localFacingDirection: Vector4,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "resultIsDelta"))]
78 #[cfg_attr(feature = "serde", serde(rename = "resultIsDelta"))]
79 pub m_resultIsDelta: bool,
80}
81const _: () = {
82 use havok_serde as _serde;
83 impl<'a> _serde::HavokClass for hkbComputeRotationToTargetModifier<'a> {
84 #[inline]
85 fn name(&self) -> &'static str {
86 "hkbComputeRotationToTargetModifier"
87 }
88 #[inline]
89 fn signature(&self) -> _serde::__private::Signature {
90 _serde::__private::Signature::new(0x47665f1c)
91 }
92 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
93 fn deps_indexes(&self) -> Vec<usize> {
94 let mut v = Vec::new();
95 v.push(self.parent.parent.parent.m_variableBindingSet.get());
96 v
97 }
98 }
99 impl<'a> _serde::Serialize for hkbComputeRotationToTargetModifier<'a> {
100 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
101 where
102 S: _serde::ser::Serializer,
103 {
104 let class_meta = self
105 .__ptr
106 .map(|name| (name, _serde::__private::Signature::new(0x47665f1c)));
107 let mut serializer = __serializer
108 .serialize_struct(
109 "hkbComputeRotationToTargetModifier",
110 class_meta,
111 (160u64, 192u64),
112 )?;
113 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
114 serializer
115 .skip_field(
116 "memSizeAndFlags",
117 &self.parent.parent.parent.parent.m_memSizeAndFlags,
118 )?;
119 serializer
120 .skip_field(
121 "referenceCount",
122 &self.parent.parent.parent.parent.m_referenceCount,
123 )?;
124 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
125 serializer
126 .serialize_field(
127 "variableBindingSet",
128 &self.parent.parent.parent.m_variableBindingSet,
129 )?;
130 serializer
131 .skip_array_field(
132 "cachedBindables",
133 &self.parent.parent.parent.m_cachedBindables,
134 TypeSize::NonPtr,
135 )?;
136 serializer
137 .skip_field(
138 "areBindablesCached",
139 &self.parent.parent.parent.m_areBindablesCached,
140 )?;
141 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
142 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
143 serializer.serialize_field("name", &self.parent.parent.m_name)?;
144 serializer.skip_field("id", &self.parent.parent.m_id)?;
145 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
146 serializer
147 .skip_fixed_array_field(
148 "padNode",
149 self.parent.parent.m_padNode.as_slice(),
150 TypeSize::NonPtr,
151 )?;
152 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
153 serializer.serialize_field("enable", &self.parent.m_enable)?;
154 serializer
155 .skip_fixed_array_field(
156 "padModifier",
157 self.parent.m_padModifier.as_slice(),
158 TypeSize::NonPtr,
159 )?;
160 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
161 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
162 serializer.serialize_field("rotationOut", &self.m_rotationOut)?;
163 serializer.serialize_field("targetPosition", &self.m_targetPosition)?;
164 serializer.serialize_field("currentPosition", &self.m_currentPosition)?;
165 serializer.serialize_field("currentRotation", &self.m_currentRotation)?;
166 serializer
167 .serialize_field("localAxisOfRotation", &self.m_localAxisOfRotation)?;
168 serializer
169 .serialize_field("localFacingDirection", &self.m_localFacingDirection)?;
170 serializer.serialize_field("resultIsDelta", &self.m_resultIsDelta)?;
171 serializer.pad_field([0u8; 15usize].as_slice(), [0u8; 15usize].as_slice())?;
172 serializer.end()
173 }
174 }
175};
176#[doc(hidden)]
177#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
178const _: () = {
179 use havok_serde as _serde;
180 #[automatically_derived]
181 impl<'de> _serde::Deserialize<'de> for hkbComputeRotationToTargetModifier<'de> {
182 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
183 where
184 __D: _serde::Deserializer<'de>,
185 {
186 #[allow(non_camel_case_types)]
187 enum __Field {
188 m_variableBindingSet,
189 m_userData,
190 m_name,
191 m_enable,
192 m_rotationOut,
193 m_targetPosition,
194 m_currentPosition,
195 m_currentRotation,
196 m_localAxisOfRotation,
197 m_localFacingDirection,
198 m_resultIsDelta,
199 __ignore,
200 }
201 struct __FieldVisitor;
202 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
203 type Value = __Field;
204 fn expecting(
205 &self,
206 __formatter: &mut core::fmt::Formatter,
207 ) -> core::fmt::Result {
208 core::fmt::Formatter::write_str(__formatter, "field identifier")
209 }
210 #[allow(clippy::match_single_binding)]
212 #[allow(clippy::reversed_empty_ranges)]
213 #[allow(clippy::single_match)]
214 fn visit_key<__E>(
215 self,
216 __value: &str,
217 ) -> core::result::Result<Self::Value, __E>
218 where
219 __E: _serde::de::Error,
220 {
221 match __value {
222 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
223 "userData" => Ok(__Field::m_userData),
224 "name" => Ok(__Field::m_name),
225 "enable" => Ok(__Field::m_enable),
226 "rotationOut" => Ok(__Field::m_rotationOut),
227 "targetPosition" => Ok(__Field::m_targetPosition),
228 "currentPosition" => Ok(__Field::m_currentPosition),
229 "currentRotation" => Ok(__Field::m_currentRotation),
230 "localAxisOfRotation" => Ok(__Field::m_localAxisOfRotation),
231 "localFacingDirection" => Ok(__Field::m_localFacingDirection),
232 "resultIsDelta" => Ok(__Field::m_resultIsDelta),
233 _ => Ok(__Field::__ignore),
234 }
235 }
236 }
237 impl<'de> _serde::Deserialize<'de> for __Field {
238 #[inline]
239 fn deserialize<__D>(
240 __deserializer: __D,
241 ) -> core::result::Result<Self, __D::Error>
242 where
243 __D: _serde::Deserializer<'de>,
244 {
245 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
246 }
247 }
248 struct __hkbComputeRotationToTargetModifierVisitor<'de> {
249 marker: _serde::__private::PhantomData<
250 hkbComputeRotationToTargetModifier<'de>,
251 >,
252 lifetime: _serde::__private::PhantomData<&'de ()>,
253 }
254 #[allow(clippy::match_single_binding)]
255 #[allow(clippy::reversed_empty_ranges)]
256 #[allow(clippy::single_match)]
257 impl<'de> _serde::de::Visitor<'de>
258 for __hkbComputeRotationToTargetModifierVisitor<'de> {
259 type Value = hkbComputeRotationToTargetModifier<'de>;
260 fn expecting(
261 &self,
262 __formatter: &mut core::fmt::Formatter,
263 ) -> core::fmt::Result {
264 core::fmt::Formatter::write_str(
265 __formatter,
266 "struct hkbComputeRotationToTargetModifier",
267 )
268 }
269 fn visit_struct_for_bytes<__A>(
270 self,
271 mut __map: __A,
272 ) -> _serde::__private::Result<Self::Value, __A::Error>
273 where
274 __A: _serde::de::MapAccess<'de>,
275 {
276 let __ptr = __A::class_ptr(&mut __map);
277 let parent = __A::parent_value(&mut __map)?;
278 let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
279 let mut m_targetPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
280 let mut m_currentPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
281 let mut m_currentRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
282 let mut m_localAxisOfRotation: _serde::__private::Option<Vector4> = _serde::__private::None;
283 let mut m_localFacingDirection: _serde::__private::Option<Vector4> = _serde::__private::None;
284 let mut m_resultIsDelta: _serde::__private::Option<bool> = _serde::__private::None;
285 for i in 0..7usize {
286 match i {
287 0usize => {
288 if _serde::__private::Option::is_some(&m_rotationOut) {
289 return _serde::__private::Err(
290 <__A::Error as _serde::de::Error>::duplicate_field(
291 "rotationOut",
292 ),
293 );
294 }
295 __A::pad(&mut __map, 4usize, 0usize)?;
296 m_rotationOut = _serde::__private::Some(
297 match __A::next_value::<Quaternion>(&mut __map) {
298 _serde::__private::Ok(__val) => __val,
299 _serde::__private::Err(__err) => {
300 return _serde::__private::Err(__err);
301 }
302 },
303 );
304 }
305 1usize => {
306 if _serde::__private::Option::is_some(&m_targetPosition) {
307 return _serde::__private::Err(
308 <__A::Error as _serde::de::Error>::duplicate_field(
309 "targetPosition",
310 ),
311 );
312 }
313 m_targetPosition = _serde::__private::Some(
314 match __A::next_value::<Vector4>(&mut __map) {
315 _serde::__private::Ok(__val) => __val,
316 _serde::__private::Err(__err) => {
317 return _serde::__private::Err(__err);
318 }
319 },
320 );
321 }
322 2usize => {
323 if _serde::__private::Option::is_some(&m_currentPosition) {
324 return _serde::__private::Err(
325 <__A::Error as _serde::de::Error>::duplicate_field(
326 "currentPosition",
327 ),
328 );
329 }
330 m_currentPosition = _serde::__private::Some(
331 match __A::next_value::<Vector4>(&mut __map) {
332 _serde::__private::Ok(__val) => __val,
333 _serde::__private::Err(__err) => {
334 return _serde::__private::Err(__err);
335 }
336 },
337 );
338 }
339 3usize => {
340 if _serde::__private::Option::is_some(&m_currentRotation) {
341 return _serde::__private::Err(
342 <__A::Error as _serde::de::Error>::duplicate_field(
343 "currentRotation",
344 ),
345 );
346 }
347 m_currentRotation = _serde::__private::Some(
348 match __A::next_value::<Quaternion>(&mut __map) {
349 _serde::__private::Ok(__val) => __val,
350 _serde::__private::Err(__err) => {
351 return _serde::__private::Err(__err);
352 }
353 },
354 );
355 }
356 4usize => {
357 if _serde::__private::Option::is_some(
358 &m_localAxisOfRotation,
359 ) {
360 return _serde::__private::Err(
361 <__A::Error as _serde::de::Error>::duplicate_field(
362 "localAxisOfRotation",
363 ),
364 );
365 }
366 m_localAxisOfRotation = _serde::__private::Some(
367 match __A::next_value::<Vector4>(&mut __map) {
368 _serde::__private::Ok(__val) => __val,
369 _serde::__private::Err(__err) => {
370 return _serde::__private::Err(__err);
371 }
372 },
373 );
374 }
375 5usize => {
376 if _serde::__private::Option::is_some(
377 &m_localFacingDirection,
378 ) {
379 return _serde::__private::Err(
380 <__A::Error as _serde::de::Error>::duplicate_field(
381 "localFacingDirection",
382 ),
383 );
384 }
385 m_localFacingDirection = _serde::__private::Some(
386 match __A::next_value::<Vector4>(&mut __map) {
387 _serde::__private::Ok(__val) => __val,
388 _serde::__private::Err(__err) => {
389 return _serde::__private::Err(__err);
390 }
391 },
392 );
393 }
394 6usize => {
395 if _serde::__private::Option::is_some(&m_resultIsDelta) {
396 return _serde::__private::Err(
397 <__A::Error as _serde::de::Error>::duplicate_field(
398 "resultIsDelta",
399 ),
400 );
401 }
402 m_resultIsDelta = _serde::__private::Some(
403 match __A::next_value::<bool>(&mut __map) {
404 _serde::__private::Ok(__val) => __val,
405 _serde::__private::Err(__err) => {
406 return _serde::__private::Err(__err);
407 }
408 },
409 );
410 }
411 _ => {}
412 }
413 }
414 __A::pad(&mut __map, 15usize, 15usize)?;
415 let m_rotationOut = match m_rotationOut {
416 _serde::__private::Some(__field) => __field,
417 _serde::__private::None => {
418 return _serde::__private::Err(
419 <__A::Error as _serde::de::Error>::missing_field(
420 "rotationOut",
421 ),
422 );
423 }
424 };
425 let m_targetPosition = match m_targetPosition {
426 _serde::__private::Some(__field) => __field,
427 _serde::__private::None => {
428 return _serde::__private::Err(
429 <__A::Error as _serde::de::Error>::missing_field(
430 "targetPosition",
431 ),
432 );
433 }
434 };
435 let m_currentPosition = match m_currentPosition {
436 _serde::__private::Some(__field) => __field,
437 _serde::__private::None => {
438 return _serde::__private::Err(
439 <__A::Error as _serde::de::Error>::missing_field(
440 "currentPosition",
441 ),
442 );
443 }
444 };
445 let m_currentRotation = match m_currentRotation {
446 _serde::__private::Some(__field) => __field,
447 _serde::__private::None => {
448 return _serde::__private::Err(
449 <__A::Error as _serde::de::Error>::missing_field(
450 "currentRotation",
451 ),
452 );
453 }
454 };
455 let m_localAxisOfRotation = match m_localAxisOfRotation {
456 _serde::__private::Some(__field) => __field,
457 _serde::__private::None => {
458 return _serde::__private::Err(
459 <__A::Error as _serde::de::Error>::missing_field(
460 "localAxisOfRotation",
461 ),
462 );
463 }
464 };
465 let m_localFacingDirection = match m_localFacingDirection {
466 _serde::__private::Some(__field) => __field,
467 _serde::__private::None => {
468 return _serde::__private::Err(
469 <__A::Error as _serde::de::Error>::missing_field(
470 "localFacingDirection",
471 ),
472 );
473 }
474 };
475 let m_resultIsDelta = match m_resultIsDelta {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::missing_field(
480 "resultIsDelta",
481 ),
482 );
483 }
484 };
485 _serde::__private::Ok(hkbComputeRotationToTargetModifier {
486 __ptr,
487 parent,
488 m_rotationOut,
489 m_targetPosition,
490 m_currentPosition,
491 m_currentRotation,
492 m_localAxisOfRotation,
493 m_localFacingDirection,
494 m_resultIsDelta,
495 })
496 }
497 #[allow(clippy::manual_unwrap_or_default)]
498 fn visit_struct<__A>(
499 self,
500 mut __map: __A,
501 ) -> _serde::__private::Result<Self::Value, __A::Error>
502 where
503 __A: _serde::de::MapAccess<'de>,
504 {
505 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
506 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
507 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
508 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
509 let mut m_rotationOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
510 let mut m_targetPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
511 let mut m_currentPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
512 let mut m_currentRotation: _serde::__private::Option<Quaternion> = _serde::__private::None;
513 let mut m_localAxisOfRotation: _serde::__private::Option<Vector4> = _serde::__private::None;
514 let mut m_localFacingDirection: _serde::__private::Option<Vector4> = _serde::__private::None;
515 let mut m_resultIsDelta: _serde::__private::Option<bool> = _serde::__private::None;
516 while let _serde::__private::Some(__key) = {
517 __A::next_key::<__Field>(&mut __map)?
518 } {
519 match __key {
520 __Field::m_variableBindingSet => {
521 #[cfg(
522 any(feature = "strict", feature = "ignore_duplicates")
523 )]
524 if _serde::__private::Option::is_some(
525 &m_variableBindingSet,
526 ) {
527 #[cfg(feature = "ignore_duplicates")]
528 {
529 __A::skip_value(&mut __map)?;
530 continue;
531 }
532 #[cfg(feature = "strict")]
533 return _serde::__private::Err(
534 <__A::Error as _serde::de::Error>::duplicate_field(
535 "variableBindingSet",
536 ),
537 );
538 }
539 m_variableBindingSet = _serde::__private::Some(
540 match __A::next_value::<Pointer>(&mut __map) {
541 _serde::__private::Ok(__val) => __val,
542 _serde::__private::Err(__err) => {
543 return _serde::__private::Err(__err);
544 }
545 },
546 );
547 }
548 __Field::m_userData => {
549 #[cfg(
550 any(feature = "strict", feature = "ignore_duplicates")
551 )]
552 if _serde::__private::Option::is_some(&m_userData) {
553 #[cfg(feature = "ignore_duplicates")]
554 {
555 __A::skip_value(&mut __map)?;
556 continue;
557 }
558 #[cfg(feature = "strict")]
559 return _serde::__private::Err(
560 <__A::Error as _serde::de::Error>::duplicate_field(
561 "userData",
562 ),
563 );
564 }
565 m_userData = _serde::__private::Some(
566 match __A::next_value::<Ulong>(&mut __map) {
567 _serde::__private::Ok(__val) => __val,
568 _serde::__private::Err(__err) => {
569 return _serde::__private::Err(__err);
570 }
571 },
572 );
573 }
574 __Field::m_name => {
575 #[cfg(
576 any(feature = "strict", feature = "ignore_duplicates")
577 )]
578 if _serde::__private::Option::is_some(&m_name) {
579 #[cfg(feature = "ignore_duplicates")]
580 {
581 __A::skip_value(&mut __map)?;
582 continue;
583 }
584 #[cfg(feature = "strict")]
585 return _serde::__private::Err(
586 <__A::Error as _serde::de::Error>::duplicate_field("name"),
587 );
588 }
589 m_name = _serde::__private::Some(
590 match __A::next_value::<StringPtr<'de>>(&mut __map) {
591 _serde::__private::Ok(__val) => __val,
592 _serde::__private::Err(__err) => {
593 return _serde::__private::Err(__err);
594 }
595 },
596 );
597 }
598 __Field::m_enable => {
599 #[cfg(
600 any(feature = "strict", feature = "ignore_duplicates")
601 )]
602 if _serde::__private::Option::is_some(&m_enable) {
603 #[cfg(feature = "ignore_duplicates")]
604 {
605 __A::skip_value(&mut __map)?;
606 continue;
607 }
608 #[cfg(feature = "strict")]
609 return _serde::__private::Err(
610 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
611 );
612 }
613 m_enable = _serde::__private::Some(
614 match __A::next_value::<bool>(&mut __map) {
615 _serde::__private::Ok(__val) => __val,
616 _serde::__private::Err(__err) => {
617 return _serde::__private::Err(__err);
618 }
619 },
620 );
621 }
622 __Field::m_rotationOut => {
623 #[cfg(
624 any(feature = "strict", feature = "ignore_duplicates")
625 )]
626 if _serde::__private::Option::is_some(&m_rotationOut) {
627 #[cfg(feature = "ignore_duplicates")]
628 {
629 __A::skip_value(&mut __map)?;
630 continue;
631 }
632 #[cfg(feature = "strict")]
633 return _serde::__private::Err(
634 <__A::Error as _serde::de::Error>::duplicate_field(
635 "rotationOut",
636 ),
637 );
638 }
639 m_rotationOut = _serde::__private::Some(
640 match __A::next_value::<Quaternion>(&mut __map) {
641 _serde::__private::Ok(__val) => __val,
642 _serde::__private::Err(__err) => {
643 return _serde::__private::Err(__err);
644 }
645 },
646 );
647 }
648 __Field::m_targetPosition => {
649 #[cfg(
650 any(feature = "strict", feature = "ignore_duplicates")
651 )]
652 if _serde::__private::Option::is_some(&m_targetPosition) {
653 #[cfg(feature = "ignore_duplicates")]
654 {
655 __A::skip_value(&mut __map)?;
656 continue;
657 }
658 #[cfg(feature = "strict")]
659 return _serde::__private::Err(
660 <__A::Error as _serde::de::Error>::duplicate_field(
661 "targetPosition",
662 ),
663 );
664 }
665 m_targetPosition = _serde::__private::Some(
666 match __A::next_value::<Vector4>(&mut __map) {
667 _serde::__private::Ok(__val) => __val,
668 _serde::__private::Err(__err) => {
669 return _serde::__private::Err(__err);
670 }
671 },
672 );
673 }
674 __Field::m_currentPosition => {
675 #[cfg(
676 any(feature = "strict", feature = "ignore_duplicates")
677 )]
678 if _serde::__private::Option::is_some(&m_currentPosition) {
679 #[cfg(feature = "ignore_duplicates")]
680 {
681 __A::skip_value(&mut __map)?;
682 continue;
683 }
684 #[cfg(feature = "strict")]
685 return _serde::__private::Err(
686 <__A::Error as _serde::de::Error>::duplicate_field(
687 "currentPosition",
688 ),
689 );
690 }
691 m_currentPosition = _serde::__private::Some(
692 match __A::next_value::<Vector4>(&mut __map) {
693 _serde::__private::Ok(__val) => __val,
694 _serde::__private::Err(__err) => {
695 return _serde::__private::Err(__err);
696 }
697 },
698 );
699 }
700 __Field::m_currentRotation => {
701 #[cfg(
702 any(feature = "strict", feature = "ignore_duplicates")
703 )]
704 if _serde::__private::Option::is_some(&m_currentRotation) {
705 #[cfg(feature = "ignore_duplicates")]
706 {
707 __A::skip_value(&mut __map)?;
708 continue;
709 }
710 #[cfg(feature = "strict")]
711 return _serde::__private::Err(
712 <__A::Error as _serde::de::Error>::duplicate_field(
713 "currentRotation",
714 ),
715 );
716 }
717 m_currentRotation = _serde::__private::Some(
718 match __A::next_value::<Quaternion>(&mut __map) {
719 _serde::__private::Ok(__val) => __val,
720 _serde::__private::Err(__err) => {
721 return _serde::__private::Err(__err);
722 }
723 },
724 );
725 }
726 __Field::m_localAxisOfRotation => {
727 #[cfg(
728 any(feature = "strict", feature = "ignore_duplicates")
729 )]
730 if _serde::__private::Option::is_some(
731 &m_localAxisOfRotation,
732 ) {
733 #[cfg(feature = "ignore_duplicates")]
734 {
735 __A::skip_value(&mut __map)?;
736 continue;
737 }
738 #[cfg(feature = "strict")]
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::duplicate_field(
741 "localAxisOfRotation",
742 ),
743 );
744 }
745 m_localAxisOfRotation = _serde::__private::Some(
746 match __A::next_value::<Vector4>(&mut __map) {
747 _serde::__private::Ok(__val) => __val,
748 _serde::__private::Err(__err) => {
749 return _serde::__private::Err(__err);
750 }
751 },
752 );
753 }
754 __Field::m_localFacingDirection => {
755 #[cfg(
756 any(feature = "strict", feature = "ignore_duplicates")
757 )]
758 if _serde::__private::Option::is_some(
759 &m_localFacingDirection,
760 ) {
761 #[cfg(feature = "ignore_duplicates")]
762 {
763 __A::skip_value(&mut __map)?;
764 continue;
765 }
766 #[cfg(feature = "strict")]
767 return _serde::__private::Err(
768 <__A::Error as _serde::de::Error>::duplicate_field(
769 "localFacingDirection",
770 ),
771 );
772 }
773 m_localFacingDirection = _serde::__private::Some(
774 match __A::next_value::<Vector4>(&mut __map) {
775 _serde::__private::Ok(__val) => __val,
776 _serde::__private::Err(__err) => {
777 return _serde::__private::Err(__err);
778 }
779 },
780 );
781 }
782 __Field::m_resultIsDelta => {
783 #[cfg(
784 any(feature = "strict", feature = "ignore_duplicates")
785 )]
786 if _serde::__private::Option::is_some(&m_resultIsDelta) {
787 #[cfg(feature = "ignore_duplicates")]
788 {
789 __A::skip_value(&mut __map)?;
790 continue;
791 }
792 #[cfg(feature = "strict")]
793 return _serde::__private::Err(
794 <__A::Error as _serde::de::Error>::duplicate_field(
795 "resultIsDelta",
796 ),
797 );
798 }
799 m_resultIsDelta = _serde::__private::Some(
800 match __A::next_value::<bool>(&mut __map) {
801 _serde::__private::Ok(__val) => __val,
802 _serde::__private::Err(__err) => {
803 return _serde::__private::Err(__err);
804 }
805 },
806 );
807 }
808 _ => __A::skip_value(&mut __map)?,
809 }
810 }
811 let m_variableBindingSet = match m_variableBindingSet {
812 _serde::__private::Some(__field) => __field,
813 _serde::__private::None => {
814 #[cfg(feature = "strict")]
815 return _serde::__private::Err(
816 <__A::Error as _serde::de::Error>::missing_field(
817 "variableBindingSet",
818 ),
819 );
820 #[cfg(not(feature = "strict"))] Default::default()
821 }
822 };
823 let m_userData = match m_userData {
824 _serde::__private::Some(__field) => __field,
825 _serde::__private::None => {
826 #[cfg(feature = "strict")]
827 return _serde::__private::Err(
828 <__A::Error as _serde::de::Error>::missing_field("userData"),
829 );
830 #[cfg(not(feature = "strict"))] Default::default()
831 }
832 };
833 let m_name = match m_name {
834 _serde::__private::Some(__field) => __field,
835 _serde::__private::None => {
836 #[cfg(feature = "strict")]
837 return _serde::__private::Err(
838 <__A::Error as _serde::de::Error>::missing_field("name"),
839 );
840 #[cfg(not(feature = "strict"))] Default::default()
841 }
842 };
843 let m_enable = match m_enable {
844 _serde::__private::Some(__field) => __field,
845 _serde::__private::None => {
846 #[cfg(feature = "strict")]
847 return _serde::__private::Err(
848 <__A::Error as _serde::de::Error>::missing_field("enable"),
849 );
850 #[cfg(not(feature = "strict"))] Default::default()
851 }
852 };
853 let m_rotationOut = match m_rotationOut {
854 _serde::__private::Some(__field) => __field,
855 _serde::__private::None => {
856 #[cfg(feature = "strict")]
857 return _serde::__private::Err(
858 <__A::Error as _serde::de::Error>::missing_field(
859 "rotationOut",
860 ),
861 );
862 #[cfg(not(feature = "strict"))] Default::default()
863 }
864 };
865 let m_targetPosition = match m_targetPosition {
866 _serde::__private::Some(__field) => __field,
867 _serde::__private::None => {
868 #[cfg(feature = "strict")]
869 return _serde::__private::Err(
870 <__A::Error as _serde::de::Error>::missing_field(
871 "targetPosition",
872 ),
873 );
874 #[cfg(not(feature = "strict"))] Default::default()
875 }
876 };
877 let m_currentPosition = match m_currentPosition {
878 _serde::__private::Some(__field) => __field,
879 _serde::__private::None => {
880 #[cfg(feature = "strict")]
881 return _serde::__private::Err(
882 <__A::Error as _serde::de::Error>::missing_field(
883 "currentPosition",
884 ),
885 );
886 #[cfg(not(feature = "strict"))] Default::default()
887 }
888 };
889 let m_currentRotation = match m_currentRotation {
890 _serde::__private::Some(__field) => __field,
891 _serde::__private::None => {
892 #[cfg(feature = "strict")]
893 return _serde::__private::Err(
894 <__A::Error as _serde::de::Error>::missing_field(
895 "currentRotation",
896 ),
897 );
898 #[cfg(not(feature = "strict"))] Default::default()
899 }
900 };
901 let m_localAxisOfRotation = match m_localAxisOfRotation {
902 _serde::__private::Some(__field) => __field,
903 _serde::__private::None => {
904 #[cfg(feature = "strict")]
905 return _serde::__private::Err(
906 <__A::Error as _serde::de::Error>::missing_field(
907 "localAxisOfRotation",
908 ),
909 );
910 #[cfg(not(feature = "strict"))] Default::default()
911 }
912 };
913 let m_localFacingDirection = match m_localFacingDirection {
914 _serde::__private::Some(__field) => __field,
915 _serde::__private::None => {
916 #[cfg(feature = "strict")]
917 return _serde::__private::Err(
918 <__A::Error as _serde::de::Error>::missing_field(
919 "localFacingDirection",
920 ),
921 );
922 #[cfg(not(feature = "strict"))] Default::default()
923 }
924 };
925 let m_resultIsDelta = match m_resultIsDelta {
926 _serde::__private::Some(__field) => __field,
927 _serde::__private::None => {
928 #[cfg(feature = "strict")]
929 return _serde::__private::Err(
930 <__A::Error as _serde::de::Error>::missing_field(
931 "resultIsDelta",
932 ),
933 );
934 #[cfg(not(feature = "strict"))] Default::default()
935 }
936 };
937 let __ptr = None;
938 let parent = hkBaseObject { __ptr };
939 let parent = hkReferencedObject {
940 __ptr,
941 parent,
942 ..Default::default()
943 };
944 let parent = hkbBindable {
945 __ptr,
946 parent,
947 m_variableBindingSet,
948 ..Default::default()
949 };
950 let parent = hkbNode {
951 __ptr,
952 parent,
953 m_userData,
954 m_name,
955 ..Default::default()
956 };
957 let parent = hkbModifier {
958 __ptr,
959 parent,
960 m_enable,
961 ..Default::default()
962 };
963 let __ptr = __A::class_ptr(&mut __map);
964 _serde::__private::Ok(hkbComputeRotationToTargetModifier {
965 __ptr,
966 parent,
967 m_rotationOut,
968 m_targetPosition,
969 m_currentPosition,
970 m_currentRotation,
971 m_localAxisOfRotation,
972 m_localFacingDirection,
973 m_resultIsDelta,
974 })
975 }
976 }
977 const FIELDS: &[&str] = &[
978 "rotationOut",
979 "targetPosition",
980 "currentPosition",
981 "currentRotation",
982 "localAxisOfRotation",
983 "localFacingDirection",
984 "resultIsDelta",
985 ];
986 _serde::Deserializer::deserialize_struct(
987 deserializer,
988 "hkbComputeRotationToTargetModifier",
989 FIELDS,
990 __hkbComputeRotationToTargetModifierVisitor {
991 marker: _serde::__private::PhantomData::<
992 hkbComputeRotationToTargetModifier,
993 >,
994 lifetime: _serde::__private::PhantomData,
995 },
996 )
997 }
998 }
999};