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