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