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