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 hkbClipGenerator<'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: hkbGenerator<'a>,
31 #[cfg_attr(feature = "serde", serde(borrow))]
36 #[cfg_attr(feature = "json_schema", schemars(rename = "animationName"))]
37 #[cfg_attr(feature = "serde", serde(rename = "animationName"))]
38 pub m_animationName: StringPtr<'a>,
39 #[cfg_attr(feature = "json_schema", schemars(rename = "triggers"))]
44 #[cfg_attr(feature = "serde", serde(rename = "triggers"))]
45 pub m_triggers: Pointer,
46 #[cfg_attr(feature = "json_schema", schemars(rename = "cropStartAmountLocalTime"))]
51 #[cfg_attr(feature = "serde", serde(rename = "cropStartAmountLocalTime"))]
52 pub m_cropStartAmountLocalTime: f32,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "cropEndAmountLocalTime"))]
58 #[cfg_attr(feature = "serde", serde(rename = "cropEndAmountLocalTime"))]
59 pub m_cropEndAmountLocalTime: f32,
60 #[cfg_attr(feature = "json_schema", schemars(rename = "startTime"))]
65 #[cfg_attr(feature = "serde", serde(rename = "startTime"))]
66 pub m_startTime: f32,
67 #[cfg_attr(feature = "json_schema", schemars(rename = "playbackSpeed"))]
72 #[cfg_attr(feature = "serde", serde(rename = "playbackSpeed"))]
73 pub m_playbackSpeed: f32,
74 #[cfg_attr(feature = "json_schema", schemars(rename = "enforcedDuration"))]
79 #[cfg_attr(feature = "serde", serde(rename = "enforcedDuration"))]
80 pub m_enforcedDuration: f32,
81 #[cfg_attr(feature = "json_schema", schemars(rename = "userControlledTimeFraction"))]
86 #[cfg_attr(feature = "serde", serde(rename = "userControlledTimeFraction"))]
87 pub m_userControlledTimeFraction: f32,
88 #[cfg_attr(feature = "json_schema", schemars(rename = "animationBindingIndex"))]
93 #[cfg_attr(feature = "serde", serde(rename = "animationBindingIndex"))]
94 pub m_animationBindingIndex: i16,
95 #[cfg_attr(feature = "json_schema", schemars(rename = "mode"))]
100 #[cfg_attr(feature = "serde", serde(rename = "mode"))]
101 pub m_mode: PlaybackMode,
102 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
107 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
108 pub m_flags: i8,
109 #[cfg_attr(feature = "json_schema", schemars(rename = "animDatas"))]
115 #[cfg_attr(feature = "serde", serde(rename = "animDatas"))]
116 pub m_animDatas: Vec<()>,
117 #[cfg_attr(feature = "json_schema", schemars(rename = "animationControl"))]
123 #[cfg_attr(feature = "serde", serde(rename = "animationControl"))]
124 pub m_animationControl: Pointer,
125 #[cfg_attr(feature = "json_schema", schemars(rename = "originalTriggers"))]
131 #[cfg_attr(feature = "serde", serde(rename = "originalTriggers"))]
132 pub m_originalTriggers: Pointer,
133 #[cfg_attr(feature = "json_schema", schemars(rename = "mapperData"))]
139 #[cfg_attr(feature = "serde", serde(rename = "mapperData"))]
140 pub m_mapperData: Pointer,
141 #[cfg_attr(feature = "json_schema", schemars(rename = "binding"))]
147 #[cfg_attr(feature = "serde", serde(rename = "binding"))]
148 pub m_binding: Pointer,
149 #[cfg_attr(feature = "json_schema", schemars(rename = "mirroredAnimation"))]
155 #[cfg_attr(feature = "serde", serde(rename = "mirroredAnimation"))]
156 pub m_mirroredAnimation: Pointer,
157 #[cfg_attr(feature = "json_schema", schemars(rename = "extractedMotion"))]
163 #[cfg_attr(feature = "serde", serde(rename = "extractedMotion"))]
164 pub m_extractedMotion: QsTransform,
165 #[cfg_attr(feature = "json_schema", schemars(rename = "echos"))]
171 #[cfg_attr(feature = "serde", serde(rename = "echos"))]
172 pub m_echos: Vec<()>,
173 #[cfg_attr(feature = "json_schema", schemars(rename = "localTime"))]
179 #[cfg_attr(feature = "serde", serde(rename = "localTime"))]
180 pub m_localTime: f32,
181 #[cfg_attr(feature = "json_schema", schemars(rename = "time"))]
187 #[cfg_attr(feature = "serde", serde(rename = "time"))]
188 pub m_time: f32,
189 #[cfg_attr(
195 feature = "json_schema",
196 schemars(rename = "previousUserControlledTimeFraction")
197 )]
198 #[cfg_attr(feature = "serde", serde(rename = "previousUserControlledTimeFraction"))]
199 pub m_previousUserControlledTimeFraction: f32,
200 #[cfg_attr(feature = "json_schema", schemars(rename = "bufferSize"))]
206 #[cfg_attr(feature = "serde", serde(rename = "bufferSize"))]
207 pub m_bufferSize: i32,
208 #[cfg_attr(feature = "json_schema", schemars(rename = "echoBufferSize"))]
214 #[cfg_attr(feature = "serde", serde(rename = "echoBufferSize"))]
215 pub m_echoBufferSize: i32,
216 #[cfg_attr(feature = "json_schema", schemars(rename = "atEnd"))]
222 #[cfg_attr(feature = "serde", serde(rename = "atEnd"))]
223 pub m_atEnd: bool,
224 #[cfg_attr(feature = "json_schema", schemars(rename = "ignoreStartTime"))]
230 #[cfg_attr(feature = "serde", serde(rename = "ignoreStartTime"))]
231 pub m_ignoreStartTime: bool,
232 #[cfg_attr(feature = "json_schema", schemars(rename = "pingPongBackward"))]
238 #[cfg_attr(feature = "serde", serde(rename = "pingPongBackward"))]
239 pub m_pingPongBackward: bool,
240}
241const _: () = {
242 use havok_serde as _serde;
243 impl<'a> _serde::HavokClass for hkbClipGenerator<'a> {
244 #[inline]
245 fn name(&self) -> &'static str {
246 "hkbClipGenerator"
247 }
248 #[inline]
249 fn signature(&self) -> _serde::__private::Signature {
250 _serde::__private::Signature::new(0x333b85b9)
251 }
252 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
253 fn deps_indexes(&self) -> Vec<usize> {
254 let mut v = Vec::new();
255 v.push(self.parent.parent.parent.m_variableBindingSet.get());
256 v.push(self.m_triggers.get());
257 v.push(self.m_animationControl.get());
258 v.push(self.m_originalTriggers.get());
259 v.push(self.m_mapperData.get());
260 v.push(self.m_binding.get());
261 v.push(self.m_mirroredAnimation.get());
262 v
263 }
264 }
265 impl<'a> _serde::Serialize for hkbClipGenerator<'a> {
266 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
267 where
268 S: _serde::ser::Serializer,
269 {
270 let class_meta = self
271 .__ptr
272 .map(|name| (name, _serde::__private::Signature::new(0x333b85b9)));
273 let mut serializer = __serializer
274 .serialize_struct("hkbClipGenerator", class_meta, (208u64, 272u64))?;
275 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
276 serializer
277 .skip_field(
278 "memSizeAndFlags",
279 &self.parent.parent.parent.parent.m_memSizeAndFlags,
280 )?;
281 serializer
282 .skip_field(
283 "referenceCount",
284 &self.parent.parent.parent.parent.m_referenceCount,
285 )?;
286 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
287 serializer
288 .serialize_field(
289 "variableBindingSet",
290 &self.parent.parent.parent.m_variableBindingSet,
291 )?;
292 serializer
293 .skip_array_field(
294 "cachedBindables",
295 &self.parent.parent.parent.m_cachedBindables,
296 TypeSize::NonPtr,
297 )?;
298 serializer
299 .skip_field(
300 "areBindablesCached",
301 &self.parent.parent.parent.m_areBindablesCached,
302 )?;
303 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
304 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
305 serializer.serialize_field("name", &self.parent.parent.m_name)?;
306 serializer.skip_field("id", &self.parent.parent.m_id)?;
307 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
308 serializer
309 .skip_fixed_array_field(
310 "padNode",
311 self.parent.parent.m_padNode.as_slice(),
312 TypeSize::NonPtr,
313 )?;
314 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
315 serializer.serialize_field("animationName", &self.m_animationName)?;
316 serializer.serialize_field("triggers", &self.m_triggers)?;
317 serializer
318 .serialize_field(
319 "cropStartAmountLocalTime",
320 &self.m_cropStartAmountLocalTime,
321 )?;
322 serializer
323 .serialize_field(
324 "cropEndAmountLocalTime",
325 &self.m_cropEndAmountLocalTime,
326 )?;
327 serializer.serialize_field("startTime", &self.m_startTime)?;
328 serializer.serialize_field("playbackSpeed", &self.m_playbackSpeed)?;
329 serializer.serialize_field("enforcedDuration", &self.m_enforcedDuration)?;
330 serializer
331 .serialize_field(
332 "userControlledTimeFraction",
333 &self.m_userControlledTimeFraction,
334 )?;
335 serializer
336 .serialize_field(
337 "animationBindingIndex",
338 &self.m_animationBindingIndex,
339 )?;
340 serializer.serialize_field("mode", &self.m_mode)?;
341 serializer.serialize_field("flags", &self.m_flags)?;
342 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
343 serializer
344 .skip_array_field("animDatas", &self.m_animDatas, TypeSize::NonPtr)?;
345 serializer.skip_field("animationControl", &self.m_animationControl)?;
346 serializer.skip_field("originalTriggers", &self.m_originalTriggers)?;
347 serializer.skip_field("mapperData", &self.m_mapperData)?;
348 serializer.skip_field("binding", &self.m_binding)?;
349 serializer.skip_field("mirroredAnimation", &self.m_mirroredAnimation)?;
350 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
351 serializer.skip_field("extractedMotion", &self.m_extractedMotion)?;
352 serializer.skip_array_field("echos", &self.m_echos, TypeSize::NonPtr)?;
353 serializer.skip_field("localTime", &self.m_localTime)?;
354 serializer.skip_field("time", &self.m_time)?;
355 serializer
356 .skip_field(
357 "previousUserControlledTimeFraction",
358 &self.m_previousUserControlledTimeFraction,
359 )?;
360 serializer.skip_field("bufferSize", &self.m_bufferSize)?;
361 serializer.skip_field("echoBufferSize", &self.m_echoBufferSize)?;
362 serializer.skip_field("atEnd", &self.m_atEnd)?;
363 serializer.skip_field("ignoreStartTime", &self.m_ignoreStartTime)?;
364 serializer.skip_field("pingPongBackward", &self.m_pingPongBackward)?;
365 serializer.pad_field([0u8; 13usize].as_slice(), [0u8; 9usize].as_slice())?;
366 serializer.end()
367 }
368 }
369};
370#[doc(hidden)]
371#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
372const _: () = {
373 use havok_serde as _serde;
374 #[automatically_derived]
375 impl<'de> _serde::Deserialize<'de> for hkbClipGenerator<'de> {
376 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
377 where
378 __D: _serde::Deserializer<'de>,
379 {
380 #[allow(non_camel_case_types)]
381 enum __Field {
382 m_variableBindingSet,
383 m_userData,
384 m_name,
385 m_animationName,
386 m_triggers,
387 m_cropStartAmountLocalTime,
388 m_cropEndAmountLocalTime,
389 m_startTime,
390 m_playbackSpeed,
391 m_enforcedDuration,
392 m_userControlledTimeFraction,
393 m_animationBindingIndex,
394 m_mode,
395 m_flags,
396 __ignore,
397 }
398 struct __FieldVisitor;
399 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
400 type Value = __Field;
401 fn expecting(
402 &self,
403 __formatter: &mut core::fmt::Formatter,
404 ) -> core::fmt::Result {
405 core::fmt::Formatter::write_str(__formatter, "field identifier")
406 }
407 #[allow(clippy::match_single_binding)]
409 #[allow(clippy::reversed_empty_ranges)]
410 #[allow(clippy::single_match)]
411 fn visit_key<__E>(
412 self,
413 __value: &str,
414 ) -> core::result::Result<Self::Value, __E>
415 where
416 __E: _serde::de::Error,
417 {
418 match __value {
419 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
420 "userData" => Ok(__Field::m_userData),
421 "name" => Ok(__Field::m_name),
422 "animationName" => Ok(__Field::m_animationName),
423 "triggers" => Ok(__Field::m_triggers),
424 "cropStartAmountLocalTime" => {
425 Ok(__Field::m_cropStartAmountLocalTime)
426 }
427 "cropEndAmountLocalTime" => Ok(__Field::m_cropEndAmountLocalTime),
428 "startTime" => Ok(__Field::m_startTime),
429 "playbackSpeed" => Ok(__Field::m_playbackSpeed),
430 "enforcedDuration" => Ok(__Field::m_enforcedDuration),
431 "userControlledTimeFraction" => {
432 Ok(__Field::m_userControlledTimeFraction)
433 }
434 "animationBindingIndex" => Ok(__Field::m_animationBindingIndex),
435 "mode" => Ok(__Field::m_mode),
436 "flags" => Ok(__Field::m_flags),
437 _ => Ok(__Field::__ignore),
438 }
439 }
440 }
441 impl<'de> _serde::Deserialize<'de> for __Field {
442 #[inline]
443 fn deserialize<__D>(
444 __deserializer: __D,
445 ) -> core::result::Result<Self, __D::Error>
446 where
447 __D: _serde::Deserializer<'de>,
448 {
449 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
450 }
451 }
452 struct __hkbClipGeneratorVisitor<'de> {
453 marker: _serde::__private::PhantomData<hkbClipGenerator<'de>>,
454 lifetime: _serde::__private::PhantomData<&'de ()>,
455 }
456 #[allow(clippy::match_single_binding)]
457 #[allow(clippy::reversed_empty_ranges)]
458 #[allow(clippy::single_match)]
459 impl<'de> _serde::de::Visitor<'de> for __hkbClipGeneratorVisitor<'de> {
460 type Value = hkbClipGenerator<'de>;
461 fn expecting(
462 &self,
463 __formatter: &mut core::fmt::Formatter,
464 ) -> core::fmt::Result {
465 core::fmt::Formatter::write_str(
466 __formatter,
467 "struct hkbClipGenerator",
468 )
469 }
470 fn visit_struct_for_bytes<__A>(
471 self,
472 mut __map: __A,
473 ) -> _serde::__private::Result<Self::Value, __A::Error>
474 where
475 __A: _serde::de::MapAccess<'de>,
476 {
477 let __ptr = __A::class_ptr(&mut __map);
478 let parent = __A::parent_value(&mut __map)?;
479 let mut m_animationName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
480 let mut m_triggers: _serde::__private::Option<Pointer> = _serde::__private::None;
481 let mut m_cropStartAmountLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
482 let mut m_cropEndAmountLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
483 let mut m_startTime: _serde::__private::Option<f32> = _serde::__private::None;
484 let mut m_playbackSpeed: _serde::__private::Option<f32> = _serde::__private::None;
485 let mut m_enforcedDuration: _serde::__private::Option<f32> = _serde::__private::None;
486 let mut m_userControlledTimeFraction: _serde::__private::Option<
487 f32,
488 > = _serde::__private::None;
489 let mut m_animationBindingIndex: _serde::__private::Option<i16> = _serde::__private::None;
490 let mut m_mode: _serde::__private::Option<PlaybackMode> = _serde::__private::None;
491 let mut m_flags: _serde::__private::Option<i8> = _serde::__private::None;
492 let mut m_animDatas: _serde::__private::Option<Vec<()>> = _serde::__private::None;
493 let mut m_animationControl: _serde::__private::Option<Pointer> = _serde::__private::None;
494 let mut m_originalTriggers: _serde::__private::Option<Pointer> = _serde::__private::None;
495 let mut m_mapperData: _serde::__private::Option<Pointer> = _serde::__private::None;
496 let mut m_binding: _serde::__private::Option<Pointer> = _serde::__private::None;
497 let mut m_mirroredAnimation: _serde::__private::Option<Pointer> = _serde::__private::None;
498 let mut m_extractedMotion: _serde::__private::Option<QsTransform> = _serde::__private::None;
499 let mut m_echos: _serde::__private::Option<Vec<()>> = _serde::__private::None;
500 let mut m_localTime: _serde::__private::Option<f32> = _serde::__private::None;
501 let mut m_time: _serde::__private::Option<f32> = _serde::__private::None;
502 let mut m_previousUserControlledTimeFraction: _serde::__private::Option<
503 f32,
504 > = _serde::__private::None;
505 let mut m_bufferSize: _serde::__private::Option<i32> = _serde::__private::None;
506 let mut m_echoBufferSize: _serde::__private::Option<i32> = _serde::__private::None;
507 let mut m_atEnd: _serde::__private::Option<bool> = _serde::__private::None;
508 let mut m_ignoreStartTime: _serde::__private::Option<bool> = _serde::__private::None;
509 let mut m_pingPongBackward: _serde::__private::Option<bool> = _serde::__private::None;
510 for i in 0..27usize {
511 match i {
512 0usize => {
513 if _serde::__private::Option::is_some(&m_animationName) {
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::duplicate_field(
516 "animationName",
517 ),
518 );
519 }
520 m_animationName = _serde::__private::Some(
521 match __A::next_value::<StringPtr<'de>>(&mut __map) {
522 _serde::__private::Ok(__val) => __val,
523 _serde::__private::Err(__err) => {
524 return _serde::__private::Err(__err);
525 }
526 },
527 );
528 }
529 1usize => {
530 if _serde::__private::Option::is_some(&m_triggers) {
531 return _serde::__private::Err(
532 <__A::Error as _serde::de::Error>::duplicate_field(
533 "triggers",
534 ),
535 );
536 }
537 m_triggers = _serde::__private::Some(
538 match __A::next_value::<Pointer>(&mut __map) {
539 _serde::__private::Ok(__val) => __val,
540 _serde::__private::Err(__err) => {
541 return _serde::__private::Err(__err);
542 }
543 },
544 );
545 }
546 2usize => {
547 if _serde::__private::Option::is_some(
548 &m_cropStartAmountLocalTime,
549 ) {
550 return _serde::__private::Err(
551 <__A::Error as _serde::de::Error>::duplicate_field(
552 "cropStartAmountLocalTime",
553 ),
554 );
555 }
556 m_cropStartAmountLocalTime = _serde::__private::Some(
557 match __A::next_value::<f32>(&mut __map) {
558 _serde::__private::Ok(__val) => __val,
559 _serde::__private::Err(__err) => {
560 return _serde::__private::Err(__err);
561 }
562 },
563 );
564 }
565 3usize => {
566 if _serde::__private::Option::is_some(
567 &m_cropEndAmountLocalTime,
568 ) {
569 return _serde::__private::Err(
570 <__A::Error as _serde::de::Error>::duplicate_field(
571 "cropEndAmountLocalTime",
572 ),
573 );
574 }
575 m_cropEndAmountLocalTime = _serde::__private::Some(
576 match __A::next_value::<f32>(&mut __map) {
577 _serde::__private::Ok(__val) => __val,
578 _serde::__private::Err(__err) => {
579 return _serde::__private::Err(__err);
580 }
581 },
582 );
583 }
584 4usize => {
585 if _serde::__private::Option::is_some(&m_startTime) {
586 return _serde::__private::Err(
587 <__A::Error as _serde::de::Error>::duplicate_field(
588 "startTime",
589 ),
590 );
591 }
592 m_startTime = _serde::__private::Some(
593 match __A::next_value::<f32>(&mut __map) {
594 _serde::__private::Ok(__val) => __val,
595 _serde::__private::Err(__err) => {
596 return _serde::__private::Err(__err);
597 }
598 },
599 );
600 }
601 5usize => {
602 if _serde::__private::Option::is_some(&m_playbackSpeed) {
603 return _serde::__private::Err(
604 <__A::Error as _serde::de::Error>::duplicate_field(
605 "playbackSpeed",
606 ),
607 );
608 }
609 m_playbackSpeed = _serde::__private::Some(
610 match __A::next_value::<f32>(&mut __map) {
611 _serde::__private::Ok(__val) => __val,
612 _serde::__private::Err(__err) => {
613 return _serde::__private::Err(__err);
614 }
615 },
616 );
617 }
618 6usize => {
619 if _serde::__private::Option::is_some(&m_enforcedDuration) {
620 return _serde::__private::Err(
621 <__A::Error as _serde::de::Error>::duplicate_field(
622 "enforcedDuration",
623 ),
624 );
625 }
626 m_enforcedDuration = _serde::__private::Some(
627 match __A::next_value::<f32>(&mut __map) {
628 _serde::__private::Ok(__val) => __val,
629 _serde::__private::Err(__err) => {
630 return _serde::__private::Err(__err);
631 }
632 },
633 );
634 }
635 7usize => {
636 if _serde::__private::Option::is_some(
637 &m_userControlledTimeFraction,
638 ) {
639 return _serde::__private::Err(
640 <__A::Error as _serde::de::Error>::duplicate_field(
641 "userControlledTimeFraction",
642 ),
643 );
644 }
645 m_userControlledTimeFraction = _serde::__private::Some(
646 match __A::next_value::<f32>(&mut __map) {
647 _serde::__private::Ok(__val) => __val,
648 _serde::__private::Err(__err) => {
649 return _serde::__private::Err(__err);
650 }
651 },
652 );
653 }
654 8usize => {
655 if _serde::__private::Option::is_some(
656 &m_animationBindingIndex,
657 ) {
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::duplicate_field(
660 "animationBindingIndex",
661 ),
662 );
663 }
664 m_animationBindingIndex = _serde::__private::Some(
665 match __A::next_value::<i16>(&mut __map) {
666 _serde::__private::Ok(__val) => __val,
667 _serde::__private::Err(__err) => {
668 return _serde::__private::Err(__err);
669 }
670 },
671 );
672 }
673 9usize => {
674 if _serde::__private::Option::is_some(&m_mode) {
675 return _serde::__private::Err(
676 <__A::Error as _serde::de::Error>::duplicate_field("mode"),
677 );
678 }
679 m_mode = _serde::__private::Some(
680 match __A::next_value::<PlaybackMode>(&mut __map) {
681 _serde::__private::Ok(__val) => __val,
682 _serde::__private::Err(__err) => {
683 return _serde::__private::Err(__err);
684 }
685 },
686 );
687 }
688 10usize => {
689 if _serde::__private::Option::is_some(&m_flags) {
690 return _serde::__private::Err(
691 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
692 );
693 }
694 m_flags = _serde::__private::Some(
695 match __A::next_value::<i8>(&mut __map) {
696 _serde::__private::Ok(__val) => __val,
697 _serde::__private::Err(__err) => {
698 return _serde::__private::Err(__err);
699 }
700 },
701 );
702 }
703 11usize => {
704 if _serde::__private::Option::is_some(&m_animDatas) {
705 return _serde::__private::Err(
706 <__A::Error as _serde::de::Error>::duplicate_field(
707 "animDatas",
708 ),
709 );
710 }
711 __A::pad(&mut __map, 0usize, 4usize)?;
712 m_animDatas = _serde::__private::Some(
713 match __A::next_value::<Vec<()>>(&mut __map) {
714 _serde::__private::Ok(__val) => __val,
715 _serde::__private::Err(__err) => {
716 return _serde::__private::Err(__err);
717 }
718 },
719 );
720 }
721 12usize => {
722 if _serde::__private::Option::is_some(&m_animationControl) {
723 return _serde::__private::Err(
724 <__A::Error as _serde::de::Error>::duplicate_field(
725 "animationControl",
726 ),
727 );
728 }
729 m_animationControl = _serde::__private::Some(
730 match __A::next_value::<Pointer>(&mut __map) {
731 _serde::__private::Ok(__val) => __val,
732 _serde::__private::Err(__err) => {
733 return _serde::__private::Err(__err);
734 }
735 },
736 );
737 }
738 13usize => {
739 if _serde::__private::Option::is_some(&m_originalTriggers) {
740 return _serde::__private::Err(
741 <__A::Error as _serde::de::Error>::duplicate_field(
742 "originalTriggers",
743 ),
744 );
745 }
746 m_originalTriggers = _serde::__private::Some(
747 match __A::next_value::<Pointer>(&mut __map) {
748 _serde::__private::Ok(__val) => __val,
749 _serde::__private::Err(__err) => {
750 return _serde::__private::Err(__err);
751 }
752 },
753 );
754 }
755 14usize => {
756 if _serde::__private::Option::is_some(&m_mapperData) {
757 return _serde::__private::Err(
758 <__A::Error as _serde::de::Error>::duplicate_field(
759 "mapperData",
760 ),
761 );
762 }
763 m_mapperData = _serde::__private::Some(
764 match __A::next_value::<Pointer>(&mut __map) {
765 _serde::__private::Ok(__val) => __val,
766 _serde::__private::Err(__err) => {
767 return _serde::__private::Err(__err);
768 }
769 },
770 );
771 }
772 15usize => {
773 if _serde::__private::Option::is_some(&m_binding) {
774 return _serde::__private::Err(
775 <__A::Error as _serde::de::Error>::duplicate_field(
776 "binding",
777 ),
778 );
779 }
780 m_binding = _serde::__private::Some(
781 match __A::next_value::<Pointer>(&mut __map) {
782 _serde::__private::Ok(__val) => __val,
783 _serde::__private::Err(__err) => {
784 return _serde::__private::Err(__err);
785 }
786 },
787 );
788 }
789 16usize => {
790 if _serde::__private::Option::is_some(
791 &m_mirroredAnimation,
792 ) {
793 return _serde::__private::Err(
794 <__A::Error as _serde::de::Error>::duplicate_field(
795 "mirroredAnimation",
796 ),
797 );
798 }
799 m_mirroredAnimation = _serde::__private::Some(
800 match __A::next_value::<Pointer>(&mut __map) {
801 _serde::__private::Ok(__val) => __val,
802 _serde::__private::Err(__err) => {
803 return _serde::__private::Err(__err);
804 }
805 },
806 );
807 }
808 17usize => {
809 if _serde::__private::Option::is_some(&m_extractedMotion) {
810 return _serde::__private::Err(
811 <__A::Error as _serde::de::Error>::duplicate_field(
812 "extractedMotion",
813 ),
814 );
815 }
816 __A::pad(&mut __map, 4usize, 0usize)?;
817 m_extractedMotion = _serde::__private::Some(
818 match __A::next_value::<QsTransform>(&mut __map) {
819 _serde::__private::Ok(__val) => __val,
820 _serde::__private::Err(__err) => {
821 return _serde::__private::Err(__err);
822 }
823 },
824 );
825 }
826 18usize => {
827 if _serde::__private::Option::is_some(&m_echos) {
828 return _serde::__private::Err(
829 <__A::Error as _serde::de::Error>::duplicate_field("echos"),
830 );
831 }
832 m_echos = _serde::__private::Some(
833 match __A::next_value::<Vec<()>>(&mut __map) {
834 _serde::__private::Ok(__val) => __val,
835 _serde::__private::Err(__err) => {
836 return _serde::__private::Err(__err);
837 }
838 },
839 );
840 }
841 19usize => {
842 if _serde::__private::Option::is_some(&m_localTime) {
843 return _serde::__private::Err(
844 <__A::Error as _serde::de::Error>::duplicate_field(
845 "localTime",
846 ),
847 );
848 }
849 m_localTime = _serde::__private::Some(
850 match __A::next_value::<f32>(&mut __map) {
851 _serde::__private::Ok(__val) => __val,
852 _serde::__private::Err(__err) => {
853 return _serde::__private::Err(__err);
854 }
855 },
856 );
857 }
858 20usize => {
859 if _serde::__private::Option::is_some(&m_time) {
860 return _serde::__private::Err(
861 <__A::Error as _serde::de::Error>::duplicate_field("time"),
862 );
863 }
864 m_time = _serde::__private::Some(
865 match __A::next_value::<f32>(&mut __map) {
866 _serde::__private::Ok(__val) => __val,
867 _serde::__private::Err(__err) => {
868 return _serde::__private::Err(__err);
869 }
870 },
871 );
872 }
873 21usize => {
874 if _serde::__private::Option::is_some(
875 &m_previousUserControlledTimeFraction,
876 ) {
877 return _serde::__private::Err(
878 <__A::Error as _serde::de::Error>::duplicate_field(
879 "previousUserControlledTimeFraction",
880 ),
881 );
882 }
883 m_previousUserControlledTimeFraction = _serde::__private::Some(
884 match __A::next_value::<f32>(&mut __map) {
885 _serde::__private::Ok(__val) => __val,
886 _serde::__private::Err(__err) => {
887 return _serde::__private::Err(__err);
888 }
889 },
890 );
891 }
892 22usize => {
893 if _serde::__private::Option::is_some(&m_bufferSize) {
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::duplicate_field(
896 "bufferSize",
897 ),
898 );
899 }
900 m_bufferSize = _serde::__private::Some(
901 match __A::next_value::<i32>(&mut __map) {
902 _serde::__private::Ok(__val) => __val,
903 _serde::__private::Err(__err) => {
904 return _serde::__private::Err(__err);
905 }
906 },
907 );
908 }
909 23usize => {
910 if _serde::__private::Option::is_some(&m_echoBufferSize) {
911 return _serde::__private::Err(
912 <__A::Error as _serde::de::Error>::duplicate_field(
913 "echoBufferSize",
914 ),
915 );
916 }
917 m_echoBufferSize = _serde::__private::Some(
918 match __A::next_value::<i32>(&mut __map) {
919 _serde::__private::Ok(__val) => __val,
920 _serde::__private::Err(__err) => {
921 return _serde::__private::Err(__err);
922 }
923 },
924 );
925 }
926 24usize => {
927 if _serde::__private::Option::is_some(&m_atEnd) {
928 return _serde::__private::Err(
929 <__A::Error as _serde::de::Error>::duplicate_field("atEnd"),
930 );
931 }
932 m_atEnd = _serde::__private::Some(
933 match __A::next_value::<bool>(&mut __map) {
934 _serde::__private::Ok(__val) => __val,
935 _serde::__private::Err(__err) => {
936 return _serde::__private::Err(__err);
937 }
938 },
939 );
940 }
941 25usize => {
942 if _serde::__private::Option::is_some(&m_ignoreStartTime) {
943 return _serde::__private::Err(
944 <__A::Error as _serde::de::Error>::duplicate_field(
945 "ignoreStartTime",
946 ),
947 );
948 }
949 m_ignoreStartTime = _serde::__private::Some(
950 match __A::next_value::<bool>(&mut __map) {
951 _serde::__private::Ok(__val) => __val,
952 _serde::__private::Err(__err) => {
953 return _serde::__private::Err(__err);
954 }
955 },
956 );
957 }
958 26usize => {
959 if _serde::__private::Option::is_some(&m_pingPongBackward) {
960 return _serde::__private::Err(
961 <__A::Error as _serde::de::Error>::duplicate_field(
962 "pingPongBackward",
963 ),
964 );
965 }
966 m_pingPongBackward = _serde::__private::Some(
967 match __A::next_value::<bool>(&mut __map) {
968 _serde::__private::Ok(__val) => __val,
969 _serde::__private::Err(__err) => {
970 return _serde::__private::Err(__err);
971 }
972 },
973 );
974 }
975 _ => {}
976 }
977 }
978 __A::pad(&mut __map, 13usize, 9usize)?;
979 let m_animationName = match m_animationName {
980 _serde::__private::Some(__field) => __field,
981 _serde::__private::None => {
982 return _serde::__private::Err(
983 <__A::Error as _serde::de::Error>::missing_field(
984 "animationName",
985 ),
986 );
987 }
988 };
989 let m_triggers = match m_triggers {
990 _serde::__private::Some(__field) => __field,
991 _serde::__private::None => {
992 return _serde::__private::Err(
993 <__A::Error as _serde::de::Error>::missing_field("triggers"),
994 );
995 }
996 };
997 let m_cropStartAmountLocalTime = match m_cropStartAmountLocalTime {
998 _serde::__private::Some(__field) => __field,
999 _serde::__private::None => {
1000 return _serde::__private::Err(
1001 <__A::Error as _serde::de::Error>::missing_field(
1002 "cropStartAmountLocalTime",
1003 ),
1004 );
1005 }
1006 };
1007 let m_cropEndAmountLocalTime = match m_cropEndAmountLocalTime {
1008 _serde::__private::Some(__field) => __field,
1009 _serde::__private::None => {
1010 return _serde::__private::Err(
1011 <__A::Error as _serde::de::Error>::missing_field(
1012 "cropEndAmountLocalTime",
1013 ),
1014 );
1015 }
1016 };
1017 let m_startTime = match m_startTime {
1018 _serde::__private::Some(__field) => __field,
1019 _serde::__private::None => {
1020 return _serde::__private::Err(
1021 <__A::Error as _serde::de::Error>::missing_field(
1022 "startTime",
1023 ),
1024 );
1025 }
1026 };
1027 let m_playbackSpeed = match m_playbackSpeed {
1028 _serde::__private::Some(__field) => __field,
1029 _serde::__private::None => {
1030 return _serde::__private::Err(
1031 <__A::Error as _serde::de::Error>::missing_field(
1032 "playbackSpeed",
1033 ),
1034 );
1035 }
1036 };
1037 let m_enforcedDuration = match m_enforcedDuration {
1038 _serde::__private::Some(__field) => __field,
1039 _serde::__private::None => {
1040 return _serde::__private::Err(
1041 <__A::Error as _serde::de::Error>::missing_field(
1042 "enforcedDuration",
1043 ),
1044 );
1045 }
1046 };
1047 let m_userControlledTimeFraction = match m_userControlledTimeFraction {
1048 _serde::__private::Some(__field) => __field,
1049 _serde::__private::None => {
1050 return _serde::__private::Err(
1051 <__A::Error as _serde::de::Error>::missing_field(
1052 "userControlledTimeFraction",
1053 ),
1054 );
1055 }
1056 };
1057 let m_animationBindingIndex = match m_animationBindingIndex {
1058 _serde::__private::Some(__field) => __field,
1059 _serde::__private::None => {
1060 return _serde::__private::Err(
1061 <__A::Error as _serde::de::Error>::missing_field(
1062 "animationBindingIndex",
1063 ),
1064 );
1065 }
1066 };
1067 let m_mode = match m_mode {
1068 _serde::__private::Some(__field) => __field,
1069 _serde::__private::None => {
1070 return _serde::__private::Err(
1071 <__A::Error as _serde::de::Error>::missing_field("mode"),
1072 );
1073 }
1074 };
1075 let m_flags = match m_flags {
1076 _serde::__private::Some(__field) => __field,
1077 _serde::__private::None => {
1078 return _serde::__private::Err(
1079 <__A::Error as _serde::de::Error>::missing_field("flags"),
1080 );
1081 }
1082 };
1083 let m_animDatas = match m_animDatas {
1084 _serde::__private::Some(__field) => __field,
1085 _serde::__private::None => {
1086 return _serde::__private::Err(
1087 <__A::Error as _serde::de::Error>::missing_field(
1088 "animDatas",
1089 ),
1090 );
1091 }
1092 };
1093 let m_animationControl = match m_animationControl {
1094 _serde::__private::Some(__field) => __field,
1095 _serde::__private::None => {
1096 return _serde::__private::Err(
1097 <__A::Error as _serde::de::Error>::missing_field(
1098 "animationControl",
1099 ),
1100 );
1101 }
1102 };
1103 let m_originalTriggers = match m_originalTriggers {
1104 _serde::__private::Some(__field) => __field,
1105 _serde::__private::None => {
1106 return _serde::__private::Err(
1107 <__A::Error as _serde::de::Error>::missing_field(
1108 "originalTriggers",
1109 ),
1110 );
1111 }
1112 };
1113 let m_mapperData = match m_mapperData {
1114 _serde::__private::Some(__field) => __field,
1115 _serde::__private::None => {
1116 return _serde::__private::Err(
1117 <__A::Error as _serde::de::Error>::missing_field(
1118 "mapperData",
1119 ),
1120 );
1121 }
1122 };
1123 let m_binding = match m_binding {
1124 _serde::__private::Some(__field) => __field,
1125 _serde::__private::None => {
1126 return _serde::__private::Err(
1127 <__A::Error as _serde::de::Error>::missing_field("binding"),
1128 );
1129 }
1130 };
1131 let m_mirroredAnimation = match m_mirroredAnimation {
1132 _serde::__private::Some(__field) => __field,
1133 _serde::__private::None => {
1134 return _serde::__private::Err(
1135 <__A::Error as _serde::de::Error>::missing_field(
1136 "mirroredAnimation",
1137 ),
1138 );
1139 }
1140 };
1141 let m_extractedMotion = match m_extractedMotion {
1142 _serde::__private::Some(__field) => __field,
1143 _serde::__private::None => {
1144 return _serde::__private::Err(
1145 <__A::Error as _serde::de::Error>::missing_field(
1146 "extractedMotion",
1147 ),
1148 );
1149 }
1150 };
1151 let m_echos = match m_echos {
1152 _serde::__private::Some(__field) => __field,
1153 _serde::__private::None => {
1154 return _serde::__private::Err(
1155 <__A::Error as _serde::de::Error>::missing_field("echos"),
1156 );
1157 }
1158 };
1159 let m_localTime = match m_localTime {
1160 _serde::__private::Some(__field) => __field,
1161 _serde::__private::None => {
1162 return _serde::__private::Err(
1163 <__A::Error as _serde::de::Error>::missing_field(
1164 "localTime",
1165 ),
1166 );
1167 }
1168 };
1169 let m_time = match m_time {
1170 _serde::__private::Some(__field) => __field,
1171 _serde::__private::None => {
1172 return _serde::__private::Err(
1173 <__A::Error as _serde::de::Error>::missing_field("time"),
1174 );
1175 }
1176 };
1177 let m_previousUserControlledTimeFraction = match m_previousUserControlledTimeFraction {
1178 _serde::__private::Some(__field) => __field,
1179 _serde::__private::None => {
1180 return _serde::__private::Err(
1181 <__A::Error as _serde::de::Error>::missing_field(
1182 "previousUserControlledTimeFraction",
1183 ),
1184 );
1185 }
1186 };
1187 let m_bufferSize = match m_bufferSize {
1188 _serde::__private::Some(__field) => __field,
1189 _serde::__private::None => {
1190 return _serde::__private::Err(
1191 <__A::Error as _serde::de::Error>::missing_field(
1192 "bufferSize",
1193 ),
1194 );
1195 }
1196 };
1197 let m_echoBufferSize = match m_echoBufferSize {
1198 _serde::__private::Some(__field) => __field,
1199 _serde::__private::None => {
1200 return _serde::__private::Err(
1201 <__A::Error as _serde::de::Error>::missing_field(
1202 "echoBufferSize",
1203 ),
1204 );
1205 }
1206 };
1207 let m_atEnd = match m_atEnd {
1208 _serde::__private::Some(__field) => __field,
1209 _serde::__private::None => {
1210 return _serde::__private::Err(
1211 <__A::Error as _serde::de::Error>::missing_field("atEnd"),
1212 );
1213 }
1214 };
1215 let m_ignoreStartTime = match m_ignoreStartTime {
1216 _serde::__private::Some(__field) => __field,
1217 _serde::__private::None => {
1218 return _serde::__private::Err(
1219 <__A::Error as _serde::de::Error>::missing_field(
1220 "ignoreStartTime",
1221 ),
1222 );
1223 }
1224 };
1225 let m_pingPongBackward = match m_pingPongBackward {
1226 _serde::__private::Some(__field) => __field,
1227 _serde::__private::None => {
1228 return _serde::__private::Err(
1229 <__A::Error as _serde::de::Error>::missing_field(
1230 "pingPongBackward",
1231 ),
1232 );
1233 }
1234 };
1235 _serde::__private::Ok(hkbClipGenerator {
1236 __ptr,
1237 parent,
1238 m_animationName,
1239 m_triggers,
1240 m_cropStartAmountLocalTime,
1241 m_cropEndAmountLocalTime,
1242 m_startTime,
1243 m_playbackSpeed,
1244 m_enforcedDuration,
1245 m_userControlledTimeFraction,
1246 m_animationBindingIndex,
1247 m_mode,
1248 m_flags,
1249 m_animDatas,
1250 m_animationControl,
1251 m_originalTriggers,
1252 m_mapperData,
1253 m_binding,
1254 m_mirroredAnimation,
1255 m_extractedMotion,
1256 m_echos,
1257 m_localTime,
1258 m_time,
1259 m_previousUserControlledTimeFraction,
1260 m_bufferSize,
1261 m_echoBufferSize,
1262 m_atEnd,
1263 m_ignoreStartTime,
1264 m_pingPongBackward,
1265 })
1266 }
1267 #[allow(clippy::manual_unwrap_or_default)]
1268 fn visit_struct<__A>(
1269 self,
1270 mut __map: __A,
1271 ) -> _serde::__private::Result<Self::Value, __A::Error>
1272 where
1273 __A: _serde::de::MapAccess<'de>,
1274 {
1275 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1276 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1277 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1278 let mut m_animationName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1279 let mut m_triggers: _serde::__private::Option<Pointer> = _serde::__private::None;
1280 let mut m_cropStartAmountLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
1281 let mut m_cropEndAmountLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
1282 let mut m_startTime: _serde::__private::Option<f32> = _serde::__private::None;
1283 let mut m_playbackSpeed: _serde::__private::Option<f32> = _serde::__private::None;
1284 let mut m_enforcedDuration: _serde::__private::Option<f32> = _serde::__private::None;
1285 let mut m_userControlledTimeFraction: _serde::__private::Option<
1286 f32,
1287 > = _serde::__private::None;
1288 let mut m_animationBindingIndex: _serde::__private::Option<i16> = _serde::__private::None;
1289 let mut m_mode: _serde::__private::Option<PlaybackMode> = _serde::__private::None;
1290 let mut m_flags: _serde::__private::Option<i8> = _serde::__private::None;
1291 while let _serde::__private::Some(__key) = {
1292 __A::next_key::<__Field>(&mut __map)?
1293 } {
1294 match __key {
1295 __Field::m_variableBindingSet => {
1296 #[cfg(
1297 any(feature = "strict", feature = "ignore_duplicates")
1298 )]
1299 if _serde::__private::Option::is_some(
1300 &m_variableBindingSet,
1301 ) {
1302 #[cfg(feature = "ignore_duplicates")]
1303 {
1304 __A::skip_value(&mut __map)?;
1305 continue;
1306 }
1307 #[cfg(feature = "strict")]
1308 return _serde::__private::Err(
1309 <__A::Error as _serde::de::Error>::duplicate_field(
1310 "variableBindingSet",
1311 ),
1312 );
1313 }
1314 m_variableBindingSet = _serde::__private::Some(
1315 match __A::next_value::<Pointer>(&mut __map) {
1316 _serde::__private::Ok(__val) => __val,
1317 _serde::__private::Err(__err) => {
1318 return _serde::__private::Err(__err);
1319 }
1320 },
1321 );
1322 }
1323 __Field::m_userData => {
1324 #[cfg(
1325 any(feature = "strict", feature = "ignore_duplicates")
1326 )]
1327 if _serde::__private::Option::is_some(&m_userData) {
1328 #[cfg(feature = "ignore_duplicates")]
1329 {
1330 __A::skip_value(&mut __map)?;
1331 continue;
1332 }
1333 #[cfg(feature = "strict")]
1334 return _serde::__private::Err(
1335 <__A::Error as _serde::de::Error>::duplicate_field(
1336 "userData",
1337 ),
1338 );
1339 }
1340 m_userData = _serde::__private::Some(
1341 match __A::next_value::<Ulong>(&mut __map) {
1342 _serde::__private::Ok(__val) => __val,
1343 _serde::__private::Err(__err) => {
1344 return _serde::__private::Err(__err);
1345 }
1346 },
1347 );
1348 }
1349 __Field::m_name => {
1350 #[cfg(
1351 any(feature = "strict", feature = "ignore_duplicates")
1352 )]
1353 if _serde::__private::Option::is_some(&m_name) {
1354 #[cfg(feature = "ignore_duplicates")]
1355 {
1356 __A::skip_value(&mut __map)?;
1357 continue;
1358 }
1359 #[cfg(feature = "strict")]
1360 return _serde::__private::Err(
1361 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1362 );
1363 }
1364 m_name = _serde::__private::Some(
1365 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1366 _serde::__private::Ok(__val) => __val,
1367 _serde::__private::Err(__err) => {
1368 return _serde::__private::Err(__err);
1369 }
1370 },
1371 );
1372 }
1373 __Field::m_animationName => {
1374 #[cfg(
1375 any(feature = "strict", feature = "ignore_duplicates")
1376 )]
1377 if _serde::__private::Option::is_some(&m_animationName) {
1378 #[cfg(feature = "ignore_duplicates")]
1379 {
1380 __A::skip_value(&mut __map)?;
1381 continue;
1382 }
1383 #[cfg(feature = "strict")]
1384 return _serde::__private::Err(
1385 <__A::Error as _serde::de::Error>::duplicate_field(
1386 "animationName",
1387 ),
1388 );
1389 }
1390 m_animationName = _serde::__private::Some(
1391 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1392 _serde::__private::Ok(__val) => __val,
1393 _serde::__private::Err(__err) => {
1394 return _serde::__private::Err(__err);
1395 }
1396 },
1397 );
1398 }
1399 __Field::m_triggers => {
1400 #[cfg(
1401 any(feature = "strict", feature = "ignore_duplicates")
1402 )]
1403 if _serde::__private::Option::is_some(&m_triggers) {
1404 #[cfg(feature = "ignore_duplicates")]
1405 {
1406 __A::skip_value(&mut __map)?;
1407 continue;
1408 }
1409 #[cfg(feature = "strict")]
1410 return _serde::__private::Err(
1411 <__A::Error as _serde::de::Error>::duplicate_field(
1412 "triggers",
1413 ),
1414 );
1415 }
1416 m_triggers = _serde::__private::Some(
1417 match __A::next_value::<Pointer>(&mut __map) {
1418 _serde::__private::Ok(__val) => __val,
1419 _serde::__private::Err(__err) => {
1420 return _serde::__private::Err(__err);
1421 }
1422 },
1423 );
1424 }
1425 __Field::m_cropStartAmountLocalTime => {
1426 #[cfg(
1427 any(feature = "strict", feature = "ignore_duplicates")
1428 )]
1429 if _serde::__private::Option::is_some(
1430 &m_cropStartAmountLocalTime,
1431 ) {
1432 #[cfg(feature = "ignore_duplicates")]
1433 {
1434 __A::skip_value(&mut __map)?;
1435 continue;
1436 }
1437 #[cfg(feature = "strict")]
1438 return _serde::__private::Err(
1439 <__A::Error as _serde::de::Error>::duplicate_field(
1440 "cropStartAmountLocalTime",
1441 ),
1442 );
1443 }
1444 m_cropStartAmountLocalTime = _serde::__private::Some(
1445 match __A::next_value::<f32>(&mut __map) {
1446 _serde::__private::Ok(__val) => __val,
1447 _serde::__private::Err(__err) => {
1448 return _serde::__private::Err(__err);
1449 }
1450 },
1451 );
1452 }
1453 __Field::m_cropEndAmountLocalTime => {
1454 #[cfg(
1455 any(feature = "strict", feature = "ignore_duplicates")
1456 )]
1457 if _serde::__private::Option::is_some(
1458 &m_cropEndAmountLocalTime,
1459 ) {
1460 #[cfg(feature = "ignore_duplicates")]
1461 {
1462 __A::skip_value(&mut __map)?;
1463 continue;
1464 }
1465 #[cfg(feature = "strict")]
1466 return _serde::__private::Err(
1467 <__A::Error as _serde::de::Error>::duplicate_field(
1468 "cropEndAmountLocalTime",
1469 ),
1470 );
1471 }
1472 m_cropEndAmountLocalTime = _serde::__private::Some(
1473 match __A::next_value::<f32>(&mut __map) {
1474 _serde::__private::Ok(__val) => __val,
1475 _serde::__private::Err(__err) => {
1476 return _serde::__private::Err(__err);
1477 }
1478 },
1479 );
1480 }
1481 __Field::m_startTime => {
1482 #[cfg(
1483 any(feature = "strict", feature = "ignore_duplicates")
1484 )]
1485 if _serde::__private::Option::is_some(&m_startTime) {
1486 #[cfg(feature = "ignore_duplicates")]
1487 {
1488 __A::skip_value(&mut __map)?;
1489 continue;
1490 }
1491 #[cfg(feature = "strict")]
1492 return _serde::__private::Err(
1493 <__A::Error as _serde::de::Error>::duplicate_field(
1494 "startTime",
1495 ),
1496 );
1497 }
1498 m_startTime = _serde::__private::Some(
1499 match __A::next_value::<f32>(&mut __map) {
1500 _serde::__private::Ok(__val) => __val,
1501 _serde::__private::Err(__err) => {
1502 return _serde::__private::Err(__err);
1503 }
1504 },
1505 );
1506 }
1507 __Field::m_playbackSpeed => {
1508 #[cfg(
1509 any(feature = "strict", feature = "ignore_duplicates")
1510 )]
1511 if _serde::__private::Option::is_some(&m_playbackSpeed) {
1512 #[cfg(feature = "ignore_duplicates")]
1513 {
1514 __A::skip_value(&mut __map)?;
1515 continue;
1516 }
1517 #[cfg(feature = "strict")]
1518 return _serde::__private::Err(
1519 <__A::Error as _serde::de::Error>::duplicate_field(
1520 "playbackSpeed",
1521 ),
1522 );
1523 }
1524 m_playbackSpeed = _serde::__private::Some(
1525 match __A::next_value::<f32>(&mut __map) {
1526 _serde::__private::Ok(__val) => __val,
1527 _serde::__private::Err(__err) => {
1528 return _serde::__private::Err(__err);
1529 }
1530 },
1531 );
1532 }
1533 __Field::m_enforcedDuration => {
1534 #[cfg(
1535 any(feature = "strict", feature = "ignore_duplicates")
1536 )]
1537 if _serde::__private::Option::is_some(&m_enforcedDuration) {
1538 #[cfg(feature = "ignore_duplicates")]
1539 {
1540 __A::skip_value(&mut __map)?;
1541 continue;
1542 }
1543 #[cfg(feature = "strict")]
1544 return _serde::__private::Err(
1545 <__A::Error as _serde::de::Error>::duplicate_field(
1546 "enforcedDuration",
1547 ),
1548 );
1549 }
1550 m_enforcedDuration = _serde::__private::Some(
1551 match __A::next_value::<f32>(&mut __map) {
1552 _serde::__private::Ok(__val) => __val,
1553 _serde::__private::Err(__err) => {
1554 return _serde::__private::Err(__err);
1555 }
1556 },
1557 );
1558 }
1559 __Field::m_userControlledTimeFraction => {
1560 #[cfg(
1561 any(feature = "strict", feature = "ignore_duplicates")
1562 )]
1563 if _serde::__private::Option::is_some(
1564 &m_userControlledTimeFraction,
1565 ) {
1566 #[cfg(feature = "ignore_duplicates")]
1567 {
1568 __A::skip_value(&mut __map)?;
1569 continue;
1570 }
1571 #[cfg(feature = "strict")]
1572 return _serde::__private::Err(
1573 <__A::Error as _serde::de::Error>::duplicate_field(
1574 "userControlledTimeFraction",
1575 ),
1576 );
1577 }
1578 m_userControlledTimeFraction = _serde::__private::Some(
1579 match __A::next_value::<f32>(&mut __map) {
1580 _serde::__private::Ok(__val) => __val,
1581 _serde::__private::Err(__err) => {
1582 return _serde::__private::Err(__err);
1583 }
1584 },
1585 );
1586 }
1587 __Field::m_animationBindingIndex => {
1588 #[cfg(
1589 any(feature = "strict", feature = "ignore_duplicates")
1590 )]
1591 if _serde::__private::Option::is_some(
1592 &m_animationBindingIndex,
1593 ) {
1594 #[cfg(feature = "ignore_duplicates")]
1595 {
1596 __A::skip_value(&mut __map)?;
1597 continue;
1598 }
1599 #[cfg(feature = "strict")]
1600 return _serde::__private::Err(
1601 <__A::Error as _serde::de::Error>::duplicate_field(
1602 "animationBindingIndex",
1603 ),
1604 );
1605 }
1606 m_animationBindingIndex = _serde::__private::Some(
1607 match __A::next_value::<i16>(&mut __map) {
1608 _serde::__private::Ok(__val) => __val,
1609 _serde::__private::Err(__err) => {
1610 return _serde::__private::Err(__err);
1611 }
1612 },
1613 );
1614 }
1615 __Field::m_mode => {
1616 #[cfg(
1617 any(feature = "strict", feature = "ignore_duplicates")
1618 )]
1619 if _serde::__private::Option::is_some(&m_mode) {
1620 #[cfg(feature = "ignore_duplicates")]
1621 {
1622 __A::skip_value(&mut __map)?;
1623 continue;
1624 }
1625 #[cfg(feature = "strict")]
1626 return _serde::__private::Err(
1627 <__A::Error as _serde::de::Error>::duplicate_field("mode"),
1628 );
1629 }
1630 m_mode = _serde::__private::Some(
1631 match __A::next_value::<PlaybackMode>(&mut __map) {
1632 _serde::__private::Ok(__val) => __val,
1633 _serde::__private::Err(__err) => {
1634 return _serde::__private::Err(__err);
1635 }
1636 },
1637 );
1638 }
1639 __Field::m_flags => {
1640 #[cfg(
1641 any(feature = "strict", feature = "ignore_duplicates")
1642 )]
1643 if _serde::__private::Option::is_some(&m_flags) {
1644 #[cfg(feature = "ignore_duplicates")]
1645 {
1646 __A::skip_value(&mut __map)?;
1647 continue;
1648 }
1649 #[cfg(feature = "strict")]
1650 return _serde::__private::Err(
1651 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
1652 );
1653 }
1654 m_flags = _serde::__private::Some(
1655 match __A::next_value::<i8>(&mut __map) {
1656 _serde::__private::Ok(__val) => __val,
1657 _serde::__private::Err(__err) => {
1658 return _serde::__private::Err(__err);
1659 }
1660 },
1661 );
1662 }
1663 _ => __A::skip_value(&mut __map)?,
1664 }
1665 }
1666 let m_variableBindingSet = match m_variableBindingSet {
1667 _serde::__private::Some(__field) => __field,
1668 _serde::__private::None => {
1669 #[cfg(feature = "strict")]
1670 return _serde::__private::Err(
1671 <__A::Error as _serde::de::Error>::missing_field(
1672 "variableBindingSet",
1673 ),
1674 );
1675 #[cfg(not(feature = "strict"))] Default::default()
1676 }
1677 };
1678 let m_userData = match m_userData {
1679 _serde::__private::Some(__field) => __field,
1680 _serde::__private::None => {
1681 #[cfg(feature = "strict")]
1682 return _serde::__private::Err(
1683 <__A::Error as _serde::de::Error>::missing_field("userData"),
1684 );
1685 #[cfg(not(feature = "strict"))] Default::default()
1686 }
1687 };
1688 let m_name = match m_name {
1689 _serde::__private::Some(__field) => __field,
1690 _serde::__private::None => {
1691 #[cfg(feature = "strict")]
1692 return _serde::__private::Err(
1693 <__A::Error as _serde::de::Error>::missing_field("name"),
1694 );
1695 #[cfg(not(feature = "strict"))] Default::default()
1696 }
1697 };
1698 let m_animationName = match m_animationName {
1699 _serde::__private::Some(__field) => __field,
1700 _serde::__private::None => {
1701 #[cfg(feature = "strict")]
1702 return _serde::__private::Err(
1703 <__A::Error as _serde::de::Error>::missing_field(
1704 "animationName",
1705 ),
1706 );
1707 #[cfg(not(feature = "strict"))] Default::default()
1708 }
1709 };
1710 let m_triggers = match m_triggers {
1711 _serde::__private::Some(__field) => __field,
1712 _serde::__private::None => {
1713 #[cfg(feature = "strict")]
1714 return _serde::__private::Err(
1715 <__A::Error as _serde::de::Error>::missing_field("triggers"),
1716 );
1717 #[cfg(not(feature = "strict"))] Default::default()
1718 }
1719 };
1720 let m_cropStartAmountLocalTime = match m_cropStartAmountLocalTime {
1721 _serde::__private::Some(__field) => __field,
1722 _serde::__private::None => {
1723 #[cfg(feature = "strict")]
1724 return _serde::__private::Err(
1725 <__A::Error as _serde::de::Error>::missing_field(
1726 "cropStartAmountLocalTime",
1727 ),
1728 );
1729 #[cfg(not(feature = "strict"))] Default::default()
1730 }
1731 };
1732 let m_cropEndAmountLocalTime = match m_cropEndAmountLocalTime {
1733 _serde::__private::Some(__field) => __field,
1734 _serde::__private::None => {
1735 #[cfg(feature = "strict")]
1736 return _serde::__private::Err(
1737 <__A::Error as _serde::de::Error>::missing_field(
1738 "cropEndAmountLocalTime",
1739 ),
1740 );
1741 #[cfg(not(feature = "strict"))] Default::default()
1742 }
1743 };
1744 let m_startTime = match m_startTime {
1745 _serde::__private::Some(__field) => __field,
1746 _serde::__private::None => {
1747 #[cfg(feature = "strict")]
1748 return _serde::__private::Err(
1749 <__A::Error as _serde::de::Error>::missing_field(
1750 "startTime",
1751 ),
1752 );
1753 #[cfg(not(feature = "strict"))] Default::default()
1754 }
1755 };
1756 let m_playbackSpeed = match m_playbackSpeed {
1757 _serde::__private::Some(__field) => __field,
1758 _serde::__private::None => {
1759 #[cfg(feature = "strict")]
1760 return _serde::__private::Err(
1761 <__A::Error as _serde::de::Error>::missing_field(
1762 "playbackSpeed",
1763 ),
1764 );
1765 #[cfg(not(feature = "strict"))] Default::default()
1766 }
1767 };
1768 let m_enforcedDuration = match m_enforcedDuration {
1769 _serde::__private::Some(__field) => __field,
1770 _serde::__private::None => {
1771 #[cfg(feature = "strict")]
1772 return _serde::__private::Err(
1773 <__A::Error as _serde::de::Error>::missing_field(
1774 "enforcedDuration",
1775 ),
1776 );
1777 #[cfg(not(feature = "strict"))] Default::default()
1778 }
1779 };
1780 let m_userControlledTimeFraction = match m_userControlledTimeFraction {
1781 _serde::__private::Some(__field) => __field,
1782 _serde::__private::None => {
1783 #[cfg(feature = "strict")]
1784 return _serde::__private::Err(
1785 <__A::Error as _serde::de::Error>::missing_field(
1786 "userControlledTimeFraction",
1787 ),
1788 );
1789 #[cfg(not(feature = "strict"))] Default::default()
1790 }
1791 };
1792 let m_animationBindingIndex = match m_animationBindingIndex {
1793 _serde::__private::Some(__field) => __field,
1794 _serde::__private::None => {
1795 #[cfg(feature = "strict")]
1796 return _serde::__private::Err(
1797 <__A::Error as _serde::de::Error>::missing_field(
1798 "animationBindingIndex",
1799 ),
1800 );
1801 #[cfg(not(feature = "strict"))] Default::default()
1802 }
1803 };
1804 let m_mode = match m_mode {
1805 _serde::__private::Some(__field) => __field,
1806 _serde::__private::None => {
1807 #[cfg(feature = "strict")]
1808 return _serde::__private::Err(
1809 <__A::Error as _serde::de::Error>::missing_field("mode"),
1810 );
1811 #[cfg(not(feature = "strict"))] Default::default()
1812 }
1813 };
1814 let m_flags = match m_flags {
1815 _serde::__private::Some(__field) => __field,
1816 _serde::__private::None => {
1817 #[cfg(feature = "strict")]
1818 return _serde::__private::Err(
1819 <__A::Error as _serde::de::Error>::missing_field("flags"),
1820 );
1821 #[cfg(not(feature = "strict"))] Default::default()
1822 }
1823 };
1824 let __ptr = None;
1825 let parent = hkBaseObject { __ptr };
1826 let parent = hkReferencedObject {
1827 __ptr,
1828 parent,
1829 ..Default::default()
1830 };
1831 let parent = hkbBindable {
1832 __ptr,
1833 parent,
1834 m_variableBindingSet,
1835 ..Default::default()
1836 };
1837 let parent = hkbNode {
1838 __ptr,
1839 parent,
1840 m_userData,
1841 m_name,
1842 ..Default::default()
1843 };
1844 let parent = hkbGenerator { __ptr, parent };
1845 let __ptr = __A::class_ptr(&mut __map);
1846 _serde::__private::Ok(hkbClipGenerator {
1847 __ptr,
1848 parent,
1849 m_animationName,
1850 m_triggers,
1851 m_cropStartAmountLocalTime,
1852 m_cropEndAmountLocalTime,
1853 m_startTime,
1854 m_playbackSpeed,
1855 m_enforcedDuration,
1856 m_userControlledTimeFraction,
1857 m_animationBindingIndex,
1858 m_mode,
1859 m_flags,
1860 ..Default::default()
1861 })
1862 }
1863 }
1864 const FIELDS: &[&str] = &[
1865 "animationName",
1866 "triggers",
1867 "cropStartAmountLocalTime",
1868 "cropEndAmountLocalTime",
1869 "startTime",
1870 "playbackSpeed",
1871 "enforcedDuration",
1872 "userControlledTimeFraction",
1873 "animationBindingIndex",
1874 "mode",
1875 "flags",
1876 "animDatas",
1877 "animationControl",
1878 "originalTriggers",
1879 "mapperData",
1880 "binding",
1881 "mirroredAnimation",
1882 "extractedMotion",
1883 "echos",
1884 "localTime",
1885 "time",
1886 "previousUserControlledTimeFraction",
1887 "bufferSize",
1888 "echoBufferSize",
1889 "atEnd",
1890 "ignoreStartTime",
1891 "pingPongBackward",
1892 ];
1893 _serde::Deserializer::deserialize_struct(
1894 deserializer,
1895 "hkbClipGenerator",
1896 FIELDS,
1897 __hkbClipGeneratorVisitor {
1898 marker: _serde::__private::PhantomData::<hkbClipGenerator>,
1899 lifetime: _serde::__private::PhantomData,
1900 },
1901 )
1902 }
1903 }
1904};
1905#[allow(non_upper_case_globals, non_snake_case)]
1908#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1909#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1910#[derive(
1911 Debug,
1912 Clone,
1913 Default,
1914 PartialEq,
1915 Eq,
1916 PartialOrd,
1917 Ord,
1918 num_derive::ToPrimitive,
1919 num_derive::FromPrimitive,
1920)]
1921pub enum PlaybackMode {
1922 #[default]
1923 MODE_SINGLE_PLAY = 0isize,
1924 MODE_LOOPING = 1isize,
1925 MODE_USER_CONTROLLED = 2isize,
1926 MODE_PING_PONG = 3isize,
1927 MODE_COUNT = 4isize,
1928}
1929const _: () = {
1930 use havok_serde as __serde;
1931 impl __serde::Serialize for PlaybackMode {
1932 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1933 where
1934 S: __serde::ser::Serializer,
1935 {
1936 let mut __serializer = __serializer.serialize_enum_flags()?;
1937 match self {
1938 Self::MODE_SINGLE_PLAY => {
1939 __serializer.serialize_field("MODE_SINGLE_PLAY", &0u64)
1940 }
1941 Self::MODE_LOOPING => __serializer.serialize_field("MODE_LOOPING", &1u64),
1942 Self::MODE_USER_CONTROLLED => {
1943 __serializer.serialize_field("MODE_USER_CONTROLLED", &2u64)
1944 }
1945 Self::MODE_PING_PONG => {
1946 __serializer.serialize_field("MODE_PING_PONG", &3u64)
1947 }
1948 Self::MODE_COUNT => __serializer.serialize_field("MODE_COUNT", &4u64),
1949 }?;
1950 use num_traits::ToPrimitive as _;
1951 let num = self
1952 .to_i8()
1953 .ok_or(S::Error::custom("Failed enum PlaybackMode to_i8"))?;
1954 __serializer.serialize_bits(&num)?;
1955 __serializer.end()
1956 }
1957 }
1958};
1959#[doc(hidden)]
1960#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1961const _: () = {
1962 #[allow(unused_extern_crates, clippy::useless_attribute)]
1963 extern crate havok_serde as _serde;
1964 #[automatically_derived]
1965 impl<'de> _serde::Deserialize<'de> for PlaybackMode {
1966 fn deserialize<__D>(
1967 __deserializer: __D,
1968 ) -> _serde::__private::Result<Self, __D::Error>
1969 where
1970 __D: _serde::Deserializer<'de>,
1971 {
1972 #[allow(non_camel_case_types)]
1973 #[doc(hidden)]
1974 enum __Field {
1975 __field0,
1976 __field1,
1977 __field2,
1978 __field3,
1979 __field4,
1980 }
1981 #[doc(hidden)]
1982 struct __FieldVisitor;
1983 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1984 type Value = __Field;
1985 fn expecting(
1986 &self,
1987 __formatter: &mut _serde::__private::Formatter,
1988 ) -> _serde::__private::fmt::Result {
1989 _serde::__private::Formatter::write_str(
1990 __formatter,
1991 "variant identifier",
1992 )
1993 }
1994 fn visit_int8<__E>(
1995 self,
1996 __value: i8,
1997 ) -> _serde::__private::Result<Self::Value, __E>
1998 where
1999 __E: _serde::de::Error,
2000 {
2001 match __value {
2002 0i8 => _serde::__private::Ok(__Field::__field0),
2003 1i8 => _serde::__private::Ok(__Field::__field1),
2004 2i8 => _serde::__private::Ok(__Field::__field2),
2005 3i8 => _serde::__private::Ok(__Field::__field3),
2006 4i8 => _serde::__private::Ok(__Field::__field4),
2007 _ => {
2008 _serde::__private::Err(
2009 _serde::de::Error::invalid_value(
2010 _serde::de::Unexpected::Int8(__value),
2011 &"value(i8) of variant is one of 0, 1, 2, 3, 4",
2012 ),
2013 )
2014 }
2015 }
2016 }
2017 fn visit_stringptr<__E>(
2018 self,
2019 __value: StringPtr<'de>,
2020 ) -> _serde::__private::Result<Self::Value, __E>
2021 where
2022 __E: _serde::de::Error,
2023 {
2024 if let Some(__value) = __value.into_inner() {
2025 match __value.as_ref() {
2026 v if v == "0"
2027 || v.eq_ignore_ascii_case("MODE_SINGLE_PLAY") => {
2028 _serde::__private::Ok(__Field::__field0)
2029 }
2030 v if v == "1" || v.eq_ignore_ascii_case("MODE_LOOPING") => {
2031 _serde::__private::Ok(__Field::__field1)
2032 }
2033 v if v == "2"
2034 || v.eq_ignore_ascii_case("MODE_USER_CONTROLLED") => {
2035 _serde::__private::Ok(__Field::__field2)
2036 }
2037 v if v == "3" || v.eq_ignore_ascii_case("MODE_PING_PONG") => {
2038 _serde::__private::Ok(__Field::__field3)
2039 }
2040 v if v == "4" || v.eq_ignore_ascii_case("MODE_COUNT") => {
2041 _serde::__private::Ok(__Field::__field4)
2042 }
2043 _ => {
2044 _serde::__private::Err(
2045 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2046 )
2047 }
2048 }
2049 } else {
2050 _serde::__private::Err(
2051 _serde::de::Error::unknown_variant("None", VARIANTS),
2052 )
2053 }
2054 }
2055 }
2056 impl<'de> _serde::Deserialize<'de> for __Field {
2057 #[inline]
2058 fn deserialize<__D>(
2059 __deserializer: __D,
2060 ) -> _serde::__private::Result<Self, __D::Error>
2061 where
2062 __D: _serde::Deserializer<'de>,
2063 {
2064 _serde::Deserializer::deserialize_identifier(
2065 __deserializer,
2066 _serde::de::ReadEnumSize::Int8,
2067 __FieldVisitor,
2068 )
2069 }
2070 }
2071 #[doc(hidden)]
2072 struct __Visitor<'de> {
2073 marker: _serde::__private::PhantomData<PlaybackMode>,
2074 lifetime: _serde::__private::PhantomData<&'de ()>,
2075 }
2076 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2077 type Value = PlaybackMode;
2078 fn expecting(
2079 &self,
2080 __formatter: &mut _serde::__private::Formatter,
2081 ) -> _serde::__private::fmt::Result {
2082 _serde::__private::Formatter::write_str(
2083 __formatter,
2084 "enum PlaybackMode",
2085 )
2086 }
2087 fn visit_enum<__A>(
2088 self,
2089 __data: __A,
2090 ) -> _serde::__private::Result<Self::Value, __A::Error>
2091 where
2092 __A: _serde::de::EnumAccess<'de>,
2093 {
2094 match _serde::de::EnumAccess::variant(__data)? {
2095 (__Field::__field0, __variant) => {
2096 _serde::de::VariantAccess::unit_variant(__variant)?;
2097 _serde::__private::Ok(PlaybackMode::MODE_SINGLE_PLAY)
2098 }
2099 (__Field::__field1, __variant) => {
2100 _serde::de::VariantAccess::unit_variant(__variant)?;
2101 _serde::__private::Ok(PlaybackMode::MODE_LOOPING)
2102 }
2103 (__Field::__field2, __variant) => {
2104 _serde::de::VariantAccess::unit_variant(__variant)?;
2105 _serde::__private::Ok(PlaybackMode::MODE_USER_CONTROLLED)
2106 }
2107 (__Field::__field3, __variant) => {
2108 _serde::de::VariantAccess::unit_variant(__variant)?;
2109 _serde::__private::Ok(PlaybackMode::MODE_PING_PONG)
2110 }
2111 (__Field::__field4, __variant) => {
2112 _serde::de::VariantAccess::unit_variant(__variant)?;
2113 _serde::__private::Ok(PlaybackMode::MODE_COUNT)
2114 }
2115 }
2116 }
2117 }
2118 #[doc(hidden)]
2119 const VARIANTS: &'static [&'static str] = &[
2120 "MODE_SINGLE_PLAY",
2121 "MODE_LOOPING",
2122 "MODE_USER_CONTROLLED",
2123 "MODE_PING_PONG",
2124 "MODE_COUNT",
2125 ];
2126 _serde::Deserializer::deserialize_enum(
2127 __deserializer,
2128 "PlaybackMode",
2129 VARIANTS,
2130 __Visitor {
2131 marker: _serde::__private::PhantomData::<PlaybackMode>,
2132 lifetime: _serde::__private::PhantomData,
2133 },
2134 )
2135 }
2136 }
2137};