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