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