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